lab.tol de ChRules.Iterative

Base de reglas con reglas para que un robot salga de un laberinto y areas que son laberintos, no pueden funcionar de manera aleatoria.

Declaraciones

Constantes

Set LabA01
Laberinto pequeño con un solo robot.
Set LabA02
Laberinto pequeño con un solo robot.
Set LabA11
Laberinto grande con un solo robot.
Set LabOut
Reglas para encontrar la salida, son independientes del algoritmo que se emplee, si ve la salida sale. En el caso de la salida, los algoritmos de la mano derecha o izquierda son un poco torpes, pues: - El de la derecha si pasa por la salida, pero no esta a su derecha la ignora y puede dar una larga vuelta hasta que consigue pasar por la salida quedando esta a su derecha. - El de la izquierda si pasa por la salida, pero no esta a su izquierda la ignora y puede dar una larga vuelta hasta que consigue pasar por la salida quedando esta a su izquierda.
Set LabRgh
Algoritmo de la mano de derecha, para salir de laberintos, codificado como reglas de reescritura de areas rectangulares de caracteres. Es como si el robot llevara su mano derecha pegada siempre a un pared y se prohibiera a si mismo separarla de la pared. Notese que hay casos en los que no es capaz de sacar al robot de un recinto cerrado aun cuando el robot este fuera, pero su mano derecha pegada al exterior del recinto.
Set LabOutRgh
Reglas para tomar la salida y algoritmo de la mano derecha para encontrar dicha salida salida.
Set LabLft
Algoritmo de la mano de izquierda, para salir de laberintos, codificado como reglas de reescritura de areas rectangulares de caracteres. Es como si el robot llevara su mano izquierda pegada siempre a un pared y se prohibiera a si mismo separarla de la pared. Notese que hay casos en los que no es capaz de sacar al robot de un recinto cerrado aun cuando el robot este fuera, pero su mano izquierda pegada al exterior del recinto. Es como el algoritmo de la mano derecha pero con las reglas impares intercambiadas de 2 en 2, la 1 y la 3, la 5 y la 7, etc. Las reglas estan numeradas con la misma numeracion que las de la derecha para que se observe este efecto.
Set LabOutLft
Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar dicha salida salida.
Set LabNeg
Ampliacion de la base de reglas para que cuando 2 robots intentan salir del mismo laberinto y se enfrentan el uno al otro, se dejen pasar mutuamente, negocial su solucion al conflicto. Otra forma de verlo es que cambian de direccion, pues el cuerpo de los robots al ser identico no permite distinguirlos, en cualquier caso, no se quedan bloqueados. Son solo 2 reglas a las que se añaden todas las anteriores mediante contactenacion de conjuntos. Estas 2 reglas solventan los 2 conflictos mas basicos, pero no todos.
Set LabNegOutRgh
Reglas para tomar la salida y algoritmo de la mano derecha para encontrar dicha salida salida.
Set LabNegOutLft
Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar dicha salida salida.

Constantes

Set LabA01

//////////////////////////////////////////////////////////////////////////////
Set LabA01 =
[["+v--+---------+-+",
  "|···|···|·····|·|",
  "|·|·|·|·|·+-+···|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|···|···|·|·|",
  "|·+-+·|·+--·+-+·|",
  "|·····|·······|·|",
  "+-----+-------+S+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto pequeño con un solo robot.",LabA01);
//////////////////////////////////////////////////////////////////////////////

Set LabA02

//////////////////////////////////////////////////////////////////////////////
Set LabA02 =
[["+v--+v--+-----+-+",
  "|···|···|·····|·|",
  "|·|·|·|·|·+-+···|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|···|···|·|·|",
  "|·+-+·|·+--·+-+·|",
  "|·····|·······|·|",
  "+-----+-------+S+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto pequeño con un solo robot.",LabA02);
//////////////////////////////////////////////////////////////////////////////

Set LabA11

//////////////////////////////////////////////////////////////////////////////
Set LabA11 =
[["+v--+---+-----+-+---+---+-----+",
  "|···|···|·····················|",
  "|·|·|·|·|·+-+·+-+·|·+-+·|·+-+·|",
  "|·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|···|·|·|·|···|·|···|·|",
  "|·+-+·|·+--·+-+·|·+--·|·+---+·|",
  "|···········|···|·····|·······|",
  "|·|·+-+-+---+-+·+-----+·|·+-+·|",
  "|·|·|···|·····|·|·····|·|·|·|·|",
  "|·|·|·|·|·+-+···|·|·+-+-+-+·|·|",
  "|·|·|·|·|·|·|·|·|·|·|·|···|·|·|",
  "|·|·|···|·|·|·|···|·|·|·|·|·|·|",
  "|···|·|·|···|·|·|·|·|···|···|·|",
  "+---+·|·+--·+-+·|·+-+·|·+---+·|",
  "|·····|·······|·|·····|·······|",
  "+S----+-------+-+-----+-------+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto grande con un solo robot.", LabA11);
//////////////////////////////////////////////////////////////////////////////

Set LabOut

//////////////////////////////////////////////////////////////////////////////
Set LabOut = RulGet(
   "Sv :- S· ;" + // 01) Encontro la salida a la derecha

   "v :- · ,"   + // 02) Encontro la salida al frente
   "S :- S ;"   + 

  "vS :- ·S ;"  + // 03) Encontro la salida a la izquierda

   "S :- S ,"   + // 04) Encontro la salida a su espalda
   "v :- · ;"   +
                  // ----------
                  
  "^S :- ·S ;"  + // 05) Encontro la salida a la derecha

   "S :- S ,"   + // 06) Encontro la salida al frente
   "^ :- · ;"   +  

  "S^ :- S· ;"  + // 07) Encontro la salida a la izquierda

   "^ :- · ,"   + // 08) Encontro la salida a su espalda
   "S :- S ;"   +
                  // ----------
                  
   "> :- · ,"   + // 09) Encontro la salida a la derecha
   "S :- S ;"   + 

  ">S :- ·S ;"  + // 10) Encontro la salida al frente

   "S :- S ,"   + // 11) Encontro la salida a la izquierda
   "> :- · ;"   + 

  "S> :- S· ;"  + // 12) Encontro la salida a su espalda

                  // ----------
                  
   "S :- S ,"   + // 13) Encontro la salida a su derecha
   "< :- · ;"   + 

  "S< :- S· ;"  + // 14) Encontro la salida al frente

   "< :- · ,"   + // 15) Encontro la salida a su izquierda
   "S :- S ;"   + 

  "<S :- ·S ;");  // 16) Encontro la salida a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para encontrar la salida, son independientes del algoritmo que se
emplee, si ve la salida sale.
En el caso de la salida, los algoritmos de la mano derecha o izquierda son
un poco torpes, pues:
- El de la derecha si pasa por la salida, pero no esta a su derecha la
  ignora y puede dar una larga vuelta hasta que consigue pasar por la salida
  quedando esta a su derecha.
- El de la izquierda si pasa por la salida, pero no esta a su izquierda la
  ignora y puede dar una larga vuelta hasta que consigue pasar por la salida
  quedando esta a su izquierda.",
LabOut);
//////////////////////////////////////////////////////////////////////////////

Set LabRgh

//////////////////////////////////////////////////////////////////////////////
Set LabRgh = RulGet(
  "·v :- <· ;"  + // 01) Encontro un paso a la derecha

   "v :- · ,"   + // 02) Encontro un paso al frente
   "· :- v ;"   +   

  "v· :- ·> ;"  + // 03) Encontro un paso a la izquierda

   "· :- ^ ,"   + // 04) Encontro un paso a su espalda
   "v :- · ;"   +   
                  // ----------

  "^· :- ·> ;"  + // 05) Encontro un paso a la derecha

   "· :- ^ ,"   + // 06) Encontro un paso al frente
   "^ :- · ;"   +

  "·^ :- <· ;"  + // 07) Encontro un paso a la izquierda

   "^ :- · ,"   + // 08) Encontro un paso a su espalda
   "· :- v ;"   + 
                  // ----------

   "> :- · ,"   + // 09) Encontro un paso a la derecha
   "· :- v ;"   + 

  ">· :- ·> ;"  + // 10) Encontro un paso al frente

   "· :- ^ ,"   + // 11) Encontro un paso a su izquierda
   "> :- · ;"   + 

  "·> :- <· ;"  + // 12) Encontro un paso a su espalda

                  // ----------

   "· :- ^ ,"   + // 13) Encontro un paso a la derecha
   "< :- · ;"   + 

  "·< :- <· ;"  + // 14) Encontro un paso al frente

   "< :- · ,"   + // 15) Encontro un paso a su izquierda
   "· :- v ;"   + 

  "<· :- ·> ;");  // 16) Encontro un paso a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Algoritmo de la mano de derecha, para salir de laberintos, codificado como
reglas de reescritura de areas rectangulares de caracteres.
Es como si el robot llevara su mano derecha pegada siempre a un pared y se
prohibiera a si mismo separarla de la pared.
Notese que hay casos en los que no es capaz de sacar al robot de un recinto
cerrado aun cuando el robot este fuera, pero su mano derecha
pegada al exterior del recinto.",
LabRgh);
//////////////////////////////////////////////////////////////////////////////

Set LabOutRgh

//////////////////////////////////////////////////////////////////////////////
Set LabOutRgh = LabOut << LabRgh;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano derecha para encontrar
dicha salida salida.",
LabOutRgh);
//////////////////////////////////////////////////////////////////////////////

Set LabLft

//////////////////////////////////////////////////////////////////////////////
Set LabLft = RulGet(
  "v· :- ·> ;"  + // 03) Encontro un paso a la izquierda

   "v :- · ,"   + // 02) Encontro un paso al frente
   "· :- v ;"   +   

  "·v :- <· ;"  + // 01) Encontro un paso a la derecha

   "· :- ^ ,"   + // 04) Encontro un paso a su espalda
   "v :- · ;"   +   
                  // ----------

  "·^ :- <· ;"  + // 07) Encontro un paso a la izquierda

   "· :- ^ ,"   + // 06) Encontro un paso al frente
   "^ :- · ;"   +

  "^· :- ·> ;"  + // 05) Encontro un paso a la derecha

   "^ :- · ,"   + // 08) Encontro un paso a su espalda
   "· :- v ;"   + 
                  // ----------

   "· :- ^ ,"   + // 11) Encontro un paso a su izquierda
   "> :- · ;"   + 

  ">· :- ·> ;"  + // 10) Encontro un paso al frente

   "> :- · ,"   + // 09) Encontro un paso a la derecha
   "· :- v ;"   + 

  "·> :- <· ;"  + // 12) Encontro un paso a su espalda

                  // ----------

   "< :- · ,"   + // 15) Encontro un paso a su izquierda

   "· :- v ;"   + 
  "·< :- <· ;"  + // 14) Encontro un paso al frente

   "· :- ^ ,"   + // 13) Encontro un paso a la derecha
   "< :- · ;"   + 

  "<· :- ·> ;");  // 16) Encontro un paso a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Algoritmo de la mano de izquierda, para salir de laberintos, codificado como
reglas de reescritura de areas rectangulares de caracteres.
Es como si el robot llevara su mano izquierda pegada siempre a un pared y se
prohibiera a si mismo separarla de la pared.
Notese que hay casos en los que no es capaz de sacar al robot de un recinto
cerrado aun cuando el robot este fuera, pero su mano izquierda
pegada al exterior del recinto.
Es como el algoritmo de la mano derecha pero con las reglas impares
intercambiadas de 2 en 2, la 1 y la 3, la 5 y la 7, etc.
Las reglas estan numeradas con la misma numeracion que las de la derecha
para que se observe este efecto.",
LabLft);
//////////////////////////////////////////////////////////////////////////////

Set LabOutLft

//////////////////////////////////////////////////////////////////////////////
Set LabOutLft = LabOut << LabLft;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar
dicha salida salida.",
LabOutLft);
//////////////////////////////////////////////////////////////////////////////

Set LabNeg

//////////////////////////////////////////////////////////////////////////////
Set LabNeg = RulGet(">< :- <> ;"  + // 01) Enfrentados -> cambio de direccion

                     "v :- ^ ,"   + // 02) Enfrentados -> cambio de direccion
                     "^ :- v ;");
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Ampliacion de la base de reglas para que cuando 2 robots intentan salir del
mismo laberinto y se enfrentan el uno al otro, se dejen pasar mutuamente,
negocial su solucion al conflicto.
Otra forma de verlo es que cambian de direccion, pues el cuerpo de los
robots al ser identico no permite distinguirlos, en cualquier caso,
no se quedan bloqueados.
Son solo 2 reglas a las que se añaden todas las anteriores mediante 
contactenacion de conjuntos.
Estas 2 reglas solventan los 2 conflictos mas basicos, pero no todos.",
LabNeg);
//////////////////////////////////////////////////////////////////////////////

Set LabNegOutRgh

//////////////////////////////////////////////////////////////////////////////
Set LabNegOutRgh = LabNeg << LabOutRgh;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano derecha para encontrar
dicha salida salida.",
LabNegOutRgh);
//////////////////////////////////////////////////////////////////////////////

Set LabNegOutLft

//////////////////////////////////////////////////////////////////////////////
Set LabNegOutLft = LabNeg << LabOutLft;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar
dicha salida salida.",
LabNegOutLft);
//////////////////////////////////////////////////////////////////////////////

Time oriented language

//////////////////////////////////////////////////////////////////////////////
// FILE    : lab.tol
// AUTHOR  : http://www.asolver.com
// PURPOSE : Base de reglas con reglas para que un robot salga de un laberinto
// y areas que son laberintos, no pueden funcionar de manera aleatoria.
//////////////////////////////////////////////////////////////////////////////


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

//////////////////////////////////////////////////////////////////////////////
Set LabA01 =
[["+v--+---------+-+",
  "|···|···|·····|·|",
  "|·|·|·|·|·+-+···|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|···|···|·|·|",
  "|·+-+·|·+--·+-+·|",
  "|·····|·······|·|",
  "+-----+-------+S+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto pequeño con un solo robot.",LabA01);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabA02 =
[["+v--+v--+-----+-+",
  "|···|···|·····|·|",
  "|·|·|·|·|·+-+···|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|",
  "|·|·|···|···|·|·|",
  "|·+-+·|·+--·+-+·|",
  "|·····|·······|·|",
  "+-----+-------+S+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto pequeño con un solo robot.",LabA02);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabA11 =
[["+v--+---+-----+-+---+---+-----+",
  "|···|···|·····················|",
  "|·|·|·|·|·+-+·+-+·|·+-+·|·+-+·|",
  "|·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|",
  "|·|·|·|·|···|·|·|·|···|·|···|·|",
  "|·+-+·|·+--·+-+·|·+--·|·+---+·|",
  "|···········|···|·····|·······|",
  "|·|·+-+-+---+-+·+-----+·|·+-+·|",
  "|·|·|···|·····|·|·····|·|·|·|·|",
  "|·|·|·|·|·+-+···|·|·+-+-+-+·|·|",
  "|·|·|·|·|·|·|·|·|·|·|·|···|·|·|",
  "|·|·|···|·|·|·|···|·|·|·|·|·|·|",
  "|···|·|·|···|·|·|·|·|···|···|·|",
  "+---+·|·+--·+-+·|·+-+·|·+---+·|",
  "|·····|·······|·|·····|·······|",
  "+S----+-------+-+-----+-------+"]];
//////////////////////////////////////////////////////////////////////////////
PutDescription("Laberinto grande con un solo robot.", LabA11);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabOut = RulGet(
   "Sv :- S· ;" + // 01) Encontro la salida a la derecha

   "v :- · ,"   + // 02) Encontro la salida al frente
   "S :- S ;"   + 

  "vS :- ·S ;"  + // 03) Encontro la salida a la izquierda

   "S :- S ,"   + // 04) Encontro la salida a su espalda
   "v :- · ;"   +
                  // ----------
                  
  "^S :- ·S ;"  + // 05) Encontro la salida a la derecha

   "S :- S ,"   + // 06) Encontro la salida al frente
   "^ :- · ;"   +  

  "S^ :- S· ;"  + // 07) Encontro la salida a la izquierda

   "^ :- · ,"   + // 08) Encontro la salida a su espalda
   "S :- S ;"   +
                  // ----------
                  
   "> :- · ,"   + // 09) Encontro la salida a la derecha
   "S :- S ;"   + 

  ">S :- ·S ;"  + // 10) Encontro la salida al frente

   "S :- S ,"   + // 11) Encontro la salida a la izquierda
   "> :- · ;"   + 

  "S> :- S· ;"  + // 12) Encontro la salida a su espalda

                  // ----------
                  
   "S :- S ,"   + // 13) Encontro la salida a su derecha
   "< :- · ;"   + 

  "S< :- S· ;"  + // 14) Encontro la salida al frente

   "< :- · ,"   + // 15) Encontro la salida a su izquierda
   "S :- S ;"   + 

  "<S :- ·S ;");  // 16) Encontro la salida a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para encontrar la salida, son independientes del algoritmo que se
emplee, si ve la salida sale.
En el caso de la salida, los algoritmos de la mano derecha o izquierda son
un poco torpes, pues:
- El de la derecha si pasa por la salida, pero no esta a su derecha la
  ignora y puede dar una larga vuelta hasta que consigue pasar por la salida
  quedando esta a su derecha.
- El de la izquierda si pasa por la salida, pero no esta a su izquierda la
  ignora y puede dar una larga vuelta hasta que consigue pasar por la salida
  quedando esta a su izquierda.",
LabOut);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabRgh = RulGet(
  "·v :- <· ;"  + // 01) Encontro un paso a la derecha

   "v :- · ,"   + // 02) Encontro un paso al frente
   "· :- v ;"   +   

  "v· :- ·> ;"  + // 03) Encontro un paso a la izquierda

   "· :- ^ ,"   + // 04) Encontro un paso a su espalda
   "v :- · ;"   +   
                  // ----------

  "^· :- ·> ;"  + // 05) Encontro un paso a la derecha

   "· :- ^ ,"   + // 06) Encontro un paso al frente
   "^ :- · ;"   +

  "·^ :- <· ;"  + // 07) Encontro un paso a la izquierda

   "^ :- · ,"   + // 08) Encontro un paso a su espalda
   "· :- v ;"   + 
                  // ----------

   "> :- · ,"   + // 09) Encontro un paso a la derecha
   "· :- v ;"   + 

  ">· :- ·> ;"  + // 10) Encontro un paso al frente

   "· :- ^ ,"   + // 11) Encontro un paso a su izquierda
   "> :- · ;"   + 

  "·> :- <· ;"  + // 12) Encontro un paso a su espalda

                  // ----------

   "· :- ^ ,"   + // 13) Encontro un paso a la derecha
   "< :- · ;"   + 

  "·< :- <· ;"  + // 14) Encontro un paso al frente

   "< :- · ,"   + // 15) Encontro un paso a su izquierda
   "· :- v ;"   + 

  "<· :- ·> ;");  // 16) Encontro un paso a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Algoritmo de la mano de derecha, para salir de laberintos, codificado como
reglas de reescritura de areas rectangulares de caracteres.
Es como si el robot llevara su mano derecha pegada siempre a un pared y se
prohibiera a si mismo separarla de la pared.
Notese que hay casos en los que no es capaz de sacar al robot de un recinto
cerrado aun cuando el robot este fuera, pero su mano derecha
pegada al exterior del recinto.",
LabRgh);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabOutRgh = LabOut << LabRgh;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano derecha para encontrar
dicha salida salida.",
LabOutRgh);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabLft = RulGet(
  "v· :- ·> ;"  + // 03) Encontro un paso a la izquierda

   "v :- · ,"   + // 02) Encontro un paso al frente
   "· :- v ;"   +   

  "·v :- <· ;"  + // 01) Encontro un paso a la derecha

   "· :- ^ ,"   + // 04) Encontro un paso a su espalda
   "v :- · ;"   +   
                  // ----------

  "·^ :- <· ;"  + // 07) Encontro un paso a la izquierda

   "· :- ^ ,"   + // 06) Encontro un paso al frente
   "^ :- · ;"   +

  "^· :- ·> ;"  + // 05) Encontro un paso a la derecha

   "^ :- · ,"   + // 08) Encontro un paso a su espalda
   "· :- v ;"   + 
                  // ----------

   "· :- ^ ,"   + // 11) Encontro un paso a su izquierda
   "> :- · ;"   + 

  ">· :- ·> ;"  + // 10) Encontro un paso al frente

   "> :- · ,"   + // 09) Encontro un paso a la derecha
   "· :- v ;"   + 

  "·> :- <· ;"  + // 12) Encontro un paso a su espalda

                  // ----------

   "< :- · ,"   + // 15) Encontro un paso a su izquierda

   "· :- v ;"   + 
  "·< :- <· ;"  + // 14) Encontro un paso al frente

   "· :- ^ ,"   + // 13) Encontro un paso a la derecha
   "< :- · ;"   + 

  "<· :- ·> ;");  // 16) Encontro un paso a su espalda
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Algoritmo de la mano de izquierda, para salir de laberintos, codificado como
reglas de reescritura de areas rectangulares de caracteres.
Es como si el robot llevara su mano izquierda pegada siempre a un pared y se
prohibiera a si mismo separarla de la pared.
Notese que hay casos en los que no es capaz de sacar al robot de un recinto
cerrado aun cuando el robot este fuera, pero su mano izquierda
pegada al exterior del recinto.
Es como el algoritmo de la mano derecha pero con las reglas impares
intercambiadas de 2 en 2, la 1 y la 3, la 5 y la 7, etc.
Las reglas estan numeradas con la misma numeracion que las de la derecha
para que se observe este efecto.",
LabLft);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabOutLft = LabOut << LabLft;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar
dicha salida salida.",
LabOutLft);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabNeg = RulGet(">< :- <> ;"  + // 01) Enfrentados -> cambio de direccion

                     "v :- ^ ,"   + // 02) Enfrentados -> cambio de direccion
                     "^ :- v ;");
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Ampliacion de la base de reglas para que cuando 2 robots intentan salir del
mismo laberinto y se enfrentan el uno al otro, se dejen pasar mutuamente,
negocial su solucion al conflicto.
Otra forma de verlo es que cambian de direccion, pues el cuerpo de los
robots al ser identico no permite distinguirlos, en cualquier caso,
no se quedan bloqueados.
Son solo 2 reglas a las que se añaden todas las anteriores mediante 
contactenacion de conjuntos.
Estas 2 reglas solventan los 2 conflictos mas basicos, pero no todos.",
LabNeg);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabNegOutRgh = LabNeg << LabOutRgh;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano derecha para encontrar
dicha salida salida.",
LabNegOutRgh);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set LabNegOutLft = LabNeg << LabOutLft;
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Reglas para tomar la salida y algoritmo de la mano izquierda para encontrar
dicha salida salida.",
LabNegOutLft);
//////////////////////////////////////////////////////////////////////////////

Árbol de ficheros

ChRules.Iterative programa de aplicacion iterativa de reglas de areas 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
- cmm funciones comunes
  - ←txt.tol funciones de textos
  - ←set.tol funciones de conjuntos
  - ←dir.tol funciones de directorios
- app directorio funciones y datos de areas, reglas y motor de reglas
  - ←are.tol funciones de areas sobre las que se aplican las reglas
  - ←rul.tol funciones de reglas que transforman de areas de caracteres
  - ←eng.tol funciones del motor iterativo de aplicacion de reglas
  - ←bub.tol para realizar un orden parcial con metodo de burbuja
  - ←cel.tol automata celular con reglas de reproduccion y muerte
  - ←lab.tol base de reglas para que un robot salga de un laberinto
  - ←fll.tol base de reglas para rellenar, fill, superficies cerradas
  - ←pon.tol base de reglas de un pingpong electronico, pong
- ←inc.tol para la inclusion de funciones, areas y bases de reglas
simulator directorio del simulador en Javascript del motor iterativo de reglas
- 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
→automata_celular_al_azar.html automata celular de reglas al azar de reproduccion y muerte
→automata_celular_determinista.html automata celular determinista de reglas de reproduccion y muerte
→burbuja_y_sedimentos.html orden parcial con metodo de burbuja simulando una sedimentacion
→laberinto_2_cabezones.html laberinto con 2 robots que se autobloquean y no pueden salir
→laberinto_2_negociadores.html laberinto con 2 robots y reglas para resolver su mutuo bloqueo
→laberinto_mas_grande.html robot que sale del laberinto aplicando reglas de la mano derecha
→laberinto_mano_izquierda_html robot que busca la salida aplicando reglas de la mano izquierda
→laberinto_mini_1_robot.html pequeño laberinto con un robot y reglas de la mano derecha
→partida_de_pong_al_15.html partida de pong donde el 15% de las veces las reglas son al azar
→partida_de_pong_al_20.html partida de pong donde el 20% de las veces las reglas son al azar
→partida_de_pong_azarosa.html partida de pingpong electronico, pong, con reglas aleatorias
→partida_de_pong_eterna.html ciclo eterno de una partida de pong, con reglas deterministas
→rellena_caja_al_azar.html reglas para llenar superficies aplicadas a una caja con lineas
→rellena_k_al_azar.html rellenado de superficies aplicado al interior de una letra K
→simulator.html simulador del motor iterativo de reglas de areas de caracteres
→chrules_iterative.pdf funciones del motor de aplicacion de reglas de caracteres

Secciones de la página

Artículos del sitio

Por categorías