home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 275_01 / lcau31.c < prev   
Text File  |  1980-01-01  |  24KB  |  833 lines
  1.  
  2. /* lcau31.c                */
  3. /* (3,1) Linear Cellular Automaton    */
  4.  
  5. /* Reference:                */
  6. /*                    */
  7. /*    Kenneth E. Perry            */
  8. /*    Abstract Mathematical Art        */
  9. /*    BYTE                */
  10. /*    December, 1986            */
  11. /*    pages 181-192            */
  12.  
  13. /*    Copyright (C) 1987        */
  14. /*    Copyright (C) 1988        */
  15. /*    Harold V. McIntosh        */
  16. /*    Gerardo Cisneros S.        */
  17.  
  18. /* G. Cisneros, 4.3.87                        */
  19. /* 10 April 1987 - modified for (4,2) [HVM]            */
  20. /* 26 April 1987 - Multiple menus [HVM]                */
  21. /* 28 April 1987 - back modified to (4,1) [HVM]            */
  22. /* 28 April 1987 - version for XVI Feria de Puebla [HVM]    */
  23. /* 14 May 1987 - modified for (3,1) and general rule [HVM]    */
  24. /* 19 May 1987 - modified for (2,2) [HVM]            */
  25. /* 20 May 1987 - modified for (2,3) [HVM]            */
  26. /* 8 June 1987 - general rule for (4,1) [HVM]             */
  27. /* 12 June 1987 - cartesian product of (2,1) rules [HVM]    */
  28. /* 12 June 1987 - (2,1) rule with memory  [HVM]            */
  29. /* 14 June 1987 - individual cycles of evolution [HVM]        */
  30. /* 17 June 1987 - p-adic representation in plane [HVM]        */
  31. /* 22 June 1987 - 2 speed gliders via 16 transitions [HVM]    */
  32. /* 26 June 1987 - push, pop the rule [HVM]            */
  33. /* 26 June 1987 - conserve position of rule cursor [HVM]    */
  34. /* 27 June 1987 - incremental rule construction [HVM]        */
  35. /* 29 June 1987 - conserve position of cell pointer [HVM]    */
  36. /* 30 June 1987 - mark & unmark transitions, xchg x&X [HVM]    */
  37. /* 25 July 1987 - display and edit de Bruijn diagrams [HVM]    */
  38. /* 27 July 1987 - graph of transition probabilities [HVM]    */
  39. /* 4 September 1987 - PROB41.C for option 't' [HVM]        */
  40. /* 21 October 1987 - program disks disappeared            */
  41. /* 24 December 1987 - program reconstructed from listings    */
  42. /* 20 February 1988 - RIJN31.C for option 'd' [HVM]        */
  43. /* 10 April 1988 - include rule engineering from LCA41 [HVM]    */
  44.  
  45. # include <bdos.h>
  46.  
  47. # define COLGRAF     4  /* graph resolution            */
  48. # define T80X25      3  /* text resolution            */
  49. # define WHCYMAG     1  /* color quad for normal screen        */
  50. # define YELREGR     2  /* color quad for alternative screen    */
  51. # define TRR        16  /* row showing totalistic rule number    */
  52. # define TRC        56  /* column for totalistic rule number    */
  53. # define XRR        12  /* row displaying totalistic rule    */
  54. # define XRC        56  /* column for totalistic rule        */
  55. # define AL        320  /* array length (screen width)        */
  56. # define SL        40    /* short array length            */
  57. # define TS         7    /* distinct sums w/totalistic rule    */
  58. # define DS        27  /* (number of distinct neighborhoods)    */
  59. # define KK         3  /* number of states per cell        */
  60. # define NX         19    /* number of sample rules        */
  61. # define BD        11  /* maximum degree of b.p.        */
  62.  
  63. char xrule[NX][KK][KK][KK];
  64.  
  65. char ixrule[NX][DS]=
  66.  
  67.     "000111011022211211212212121",    /* nice cross hatching */
  68.     "000111011022211211010101011",    /* very complex glider */
  69.     "001011121112111102122010110",    /* v. bars w/entanglement */
  70.     "001212111222012021211012110",    /* cycles on dgl bgrnd    */
  71.     "002010000121000021210121012",    /* crosshatching */
  72.     "002010110011102200201210000",    /* bin ctr */
  73.     "001212111222012021211012110",    /* cycles on dgl bgrnd    */
  74.     "010000022020011001000000012",    /* shuttle squeeze */
  75.     "010002001022011100022000102",    /* coo gldrs */
  76.     "012101100200011111020112002",    /* crocodile skin */
  77.     "012101211210021101110111010",    /* mixture of types */
  78.     "012101210121012101210221111",    /* y/o on b/g */
  79.     "020100121221001000010020101",    /* slow glider - copies bar */
  80.     "020101102122002001220120212",    /* slow glider */
  81.     "020102221122012100201010221",    /* slow & fast gliders */
  82.     "021201121221011200101210111",
  83.     "010010101111011120221112000",    /* diagonal growth on mesh */
  84.     "101010202020202010101111111",    /* skewed triangle */
  85.     "212112112111211112121211112"    /* gliderettes & latice */
  86.  
  87.     ;
  88.  
  89. char   tabl[20][SL];                    /* workspace to construct table */
  90. char   ascrule[KK][KK][KK];                /* ASCII transition values */
  91. char   auxrule[KK][KK][KK];                /* auxiliary transition table */
  92. char   rulstk[10][KK][KK][KK];                /* pushdown for rules */
  93. char   prule1[8], prule2[8];                /* product rule specification */
  94. char   trule[TS]="0130232";
  95. int    binrule[KK][KK][KK];
  96. int    arr1[AL], arr2[AL];                /* line of cells */
  97. int    ru, ru0, ru1, ru2;                /* rule cursor */
  98. int    li, lj;                        /* cell pointer */
  99. int    rulptr;                        /* rule pd ptr */
  100. int    ix0, iy0;                    /* origin for pen moves */
  101. double wmul[KK], wmvl[KK];                /* left mass point */
  102. double wmur[KK], wmvr[KK];                /* right mass point */
  103. double bp[KK][KK][KK][KK];                /* bernstein polynomial */
  104.  
  105. main() {
  106. int  i, j, i0, i1, i2;
  107. int  more = 'r';
  108. char a, b, c;
  109.  
  110. ru=6; ru0=0; ru1=0; ru2=0;
  111. li=SL/2; lj=0;
  112. rulptr=0;
  113.  
  114. for (i=0; i<NX; i++) {                    /* copy to 3-index array */
  115. i0=0; i1=0; i2=0;
  116. for (j=0; j<DS; j++) {
  117.   xrule[i][i0][i1][i2]=ixrule[i][j];
  118.   i2++;
  119.   if (i2==KK) {i2=0; i1++;};
  120.   if (i1==KK) {i1=0; i0++;};
  121.   if (i0==KK) {i0=0; };
  122. };};
  123.  
  124.     videopalette(WHCYMAG);                /* white/cyan/magenta */
  125.  
  126.     tuto();
  127.     while (!kbdst()) rand();                /* wait for keypress */
  128.     kbdin();                        /* ignore it */
  129.     videomode(T80X25);
  130.     videoscroll(3,0,5,71,0,3);                /* menu on blue background */
  131.     videoscroll(19,0,24,71,0,3);
  132.     xtoasc(rand()%NX);
  133.     ranlin();                        /* random initial array */
  134.     auxblnk();                        /* uncomitted transitions */
  135.  
  136.     while (more!='n') {                    /* execute multiple runs */
  137.     rmenu();
  138.     lmenu();
  139.     while (0<1) {                    /* set up one run */
  140.     c=kbdin();
  141.     if (c=='g') break;                    /* go draw graph */
  142.     if (c=='q') more='n';                /* quit for good */
  143.     if (more=='n') break;
  144.     switch (c) {
  145.     case '@':                    /* numbered tot rule */
  146.         nutoto(numin(0));
  147.         totoasc();
  148.         rmenu();
  149.         videocursor(0,4,0);
  150.         break;
  151.     case '$':                    /* dozen totalistics */
  152.         j=numin(0);
  153.         for (i=0; i<12; i++) {
  154.           nutoto(j+i);
  155.           totoasc();
  156.           ranlin();
  157.           evolve();
  158.           };
  159.         videomode(T80X25);
  160.         rmenu();
  161.         lmenu();
  162.         break;
  163.     case '.':                    /* one cycle of evolution */
  164.         asctobin();
  165.         onegen(AL);
  166.         clmenu();
  167.         break;
  168.     case ',':                    /* one cycle of evolution */
  169.         videomode(COLGRAF);
  170.         pgrid();
  171.         for (i=0; i<200; i++) {pprob(); onegen(AL);};
  172.         videodot(190,195,3);
  173.         kbdin();
  174.         videomode(T80X25);
  175.         rmenu();
  176.         lmenu();
  177.         break;
  178.     case 'T':                    /* totalistic rule */
  179.         xblnk();
  180.         tmenu();
  181.         edtrule();
  182.         totoasc();
  183.         for (i0=0; i0<KK; i0++) {
  184.         for (i1=0; i1<KK; i1++) {
  185.         for (i2=0; i2<KK; i2++) {
  186.         ascrule[i0][i1][i2]=trule[i0+i1+i2];
  187.         };};};
  188.         videocursor(0,4,0);
  189.         rmenu();
  190.         xmenu(totonu(0));
  191.         break;
  192.     case 't':                    /* edit tri prob plots */
  193.         edtri();
  194.         rmenu();
  195.         lmenu();
  196.         break;
  197.         case 'r':                    /* edit rule */    
  198.         xblnk();
  199.         edrule();
  200.         videocursor(0,4,0);
  201.         rmenu();
  202.         break;
  203.         case 'l':                    /* edit cell string */
  204.         xblnk();
  205.         edline(8,40);
  206.         videocursor(0,3,0);
  207.         lmenu();
  208.         break;
  209.         case '#':                    /* read stored rule */
  210.         xmenu(NX);
  211.         xtoasc(lim(1,numin(0),NX)-1);
  212.         rmenu();
  213.             break;
  214.     case 'D':                    /* run through samples */
  215.         for (i=0; i<NX; i++) {
  216.           xmenu(i);
  217.           xtoasc(i);
  218.           ranlin();
  219.           evolve();
  220.           };
  221.         videomode(T80X25);
  222.         rmenu();
  223.         break;
  224.     case 'd':                    /* de Bruijn diagram */
  225.         edijn();
  226.         rmenu();
  227.         lmenu();
  228.         break;
  229.         case 'u':                    /* sparse init arry */
  230.         xblnk();
  231.         for (i=0; i<AL; i++) arr1[i]=0;
  232.         arr1[AL/4]=1;
  233.             arr1[AL/2]=1;
  234.             arr1[(3*AL)/4]=1;
  235.             arr1[(3*AL)/4+2]=1;
  236.         lmenu();
  237.             break;
  238.     case 'X':                    /* random rule */
  239.         xblnk();
  240.         i=rand();
  241.         for (i0=0; i0<KK; i0++) {
  242.         for (i1=0; i1<KK; i1++) {
  243.         for (i2=0; i2<KK; i2++) {
  244.           if (i == 0) i=rand();
  245.           ascrule[i0][i1][i2]='0'+i%KK;
  246.           i/=KK;
  247.         };};};
  248.         rmenu();
  249.         break;
  250.     case 'x':                    /* random rule */
  251.         xblnk();
  252.         for (i0=0; i0<KK; i0++) {
  253.         for (i1=0; i1<KK; i1++) {
  254.         for (i2=0; i2<KK; i2++) {
  255.           if (