home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume14 / back-prop / part03 / io.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-15  |  23.5 KB  |  774 lines
  1. /* ************************************************ */
  2. /* file io.c:  contains most input/output functions */
  3. /*                                                  */
  4. /* Copyright (c) 1990 by Donald R. Tveter           */
  5. /*                                                  */
  6. /* ************************************************ */
  7.  
  8. #include <stdio.h>
  9. #ifdef INTEGER
  10. #include "ibp.h"
  11. #else
  12. #include "rbp.h"
  13. #endif
  14.  
  15. extern char buffer[buffsize];
  16. extern int bufferend;
  17. extern int bufferptr;
  18. extern int ch;
  19. extern FILE *data;
  20. extern char datafilename[50];
  21. extern int echo;
  22. extern int format[maxformat];
  23. extern LAYER *last;
  24. extern int lastsave;
  25. extern short nlayers;
  26. extern char outformat;
  27. extern WTTYPE qmark;
  28. extern int readerror;
  29. extern int readingpattern;
  30. extern LAYER *start;
  31. extern WTTYPE toler;
  32. extern int totaliter;
  33. extern char wtformat;
  34.  
  35. #ifdef INTEGER
  36.  
  37. short scale(x)     /* returns x as a scaled 16-bit value */
  38. double x;
  39. {
  40.   short s;
  41.   if (x > 31.999 || x < -32.0)
  42.      {
  43.        printf("magnitude of %lf is too large for the integer",x);
  44.        printf(" representation\n",x);
  45.        readerror = 1;
  46.        return(0);
  47.      };
  48.   if (x > 0.0) s = x * 1024 + 0.5;
  49.   else s = x * 1024 - 0.5;
  50.   if (x != 0.0 && s == 0)
  51.      {
  52.        printf("warning:  magnitude of %lf is too small for",x);
  53.        printf(" the integer representation\n");
  54.        return(0);
  55.      };
  56.   return(s);
  57. }
  58.  
  59. double unscale(x)  /* returns the double value of short x */
  60. short x;
  61. {
  62.   double temp;
  63.   temp = (double) x / 1024.0; 
  64.   return(temp);
  65. }
  66.  
  67. double unscaleint(x)  /* returns the double value of int x */
  68. int x;
  69. {
  70.   double temp;
  71.   temp = (double) x / 1024.0; 
  72.   return(temp);
  73. }
  74.  
  75. #endif
  76.  
  77. int readch() /* returns the next character in the input buffer */
  78. { 
  79.   int i, ch2;
  80.   if (bufferptr > bufferend) /* then read next line into buffer */
  81.      {
  82.        ch2 = getc(data);
  83.        if (ch2 == EOF) return(ch2);
  84.        i = 0;
  85.        while(ch2 != '\n' && i < buffsize)
  86.           {
  87.             if (ch2 == 015) ch2 = ' '; /* filter out carriage returns */
  88.             buffer[i] = ch2;
  89.             i = i + 1;
  90.             ch2 = getc(data);
  91.           };
  92.        if (i == buffsize)
  93.           {
  94.             printf("line too long\n");
  95.             exit(4);
  96.           };
  97.        buffer[i] = '\n';
  98.        bufferend = i;
  99.        bufferptr = 0;
  100.        if (echo == 1)
  101.           for(i = 0; i <= bufferend; i++) putchar(buffer[i]);
  102.       }
  103.   ch2 = buffer[bufferptr];
  104.   bufferptr = bufferptr + 1;
  105.   return(ch2);
  106. }
  107.  
  108. void texterror() /* handles errors in text */
  109. {
  110.  printf("unexpected text:  ");
  111.  bufferptr = bufferptr - 1;
  112.  ch = readch();
  113.  while (ch != '\n')
  114.     {
  115.       putchar(ch);
  116.       ch = readch();
  117.     };
  118.  putchar('\n');
  119.  bufferptr = bufferptr - 1;
  120. }
  121.  
  122. int scanfordigit()    /* used to scan for the leading */
  123. {                     /* digit of a number and trap mistakes */
  124.  int sign;
  125.  
  126.  sign = 1;
  127. restart:
  128.  ch = readch();
  129.  while (ch == ' ' || ch == '\n') ch = readch();
  130.  if (ch >= '0' && ch <= '9')
  131.     {
  132.       bufferptr = bufferptr - 1; /* unget the character */
  133.       return(sign);
  134.     };
  135.  if (ch >= 'h' && ch <= 'k')
  136.     {
  137.       bufferptr = bufferptr - 1; /* unget the character */
  138.       return(0);
  139.     };
  140.           switch (ch) {
  141. case EOF: printf("unexpected EOF\n");
  142.           exit(2);
  143. case '*': while (ch != '\n') ch = readch();
  144.           goto restart;
  145. case '-': sign = -sign;
  146.           goto restart;
  147. case '?': bufferptr = bufferptr - 1; /* unget the character */
  148.           return(0);
  149. default:  readerror = 1;
  150.           return(0);
  151.           }; /* end switch */
  152. };
  153.  
  154. int readint(min,max,command)
  155. int min, max;   /* the minimum and maximum allowed values */
  156. char command;
  157. {
  158.   int sign, number;
  159.   readerror = 0;
  160.   sign = scanfordigit();
  161.   if (readerror == 1 || sign == 0)
  162.      {
  163.        readerror = 1;
  164.        texterror();
  165.        return(0);
  166.      };
  167.   number = 0;
  168.   ch = readch();
  169.   while (ch == ' ') ch = readch();
  170.   while (ch >= '0' && ch <= '9')
  171.      {
  172.        number = number * 10 + (ch - '0');
  173.        ch = readch();
  174.      };
  175.   bufferptr = bufferptr - 1; /* unget the character */
  176.   number = sign * number;
  177.   if (number < min || number > max)
  178.      {
  179.        printf("erroneous value: %d",number);
  180.        if (data == stdin) putchar('\n');
  181.        else printf(" in %c command\n",command);
  182.        readerror = 1;
  183.      };
  184.   return(number);
  185. }
  186.  
  187. double readreal(op,min,command)
  188. int op;
  189. double min;
  190. int command;
  191. {
  192.   double number;
  193.   double fractpart, divisor, intpart, sign;
  194.   readerror = 0;
  195.  
  196.   sign = (double) scanfordigit();
  197.   if (readerror == 1 || (sign == 0 && !readingpattern))
  198.      {
  199.        texterror();
  200.        return(0);
  201.      };
  202.   ch = readch();
  203.   if (ch == 'h' && readingpattern)
  204.      return(unscale(HCODE));
  205.   else if (ch == 'i' && readingpattern && nlayers >= 3)
  206.           return(unscale(ICODE));
  207.   else if (ch == 'j' && readingpattern && nlayers >= 4)
  208.           return(unscale(JCODE));
  209.   else if (ch == 'k' && readingpattern && nlayers >= 5)
  210.           return(unscale(KCODE));
  211.   else if (ch == '?' && readingpattern)
  212.           return(unscale(qmark));
  213.   intpart = 0.0;
  214.   while (ch >= '0' && ch <= '9')
  215.      {
  216.        intpart = 10.0 * intpart + (ch - '0');
  217.        ch = readch();
  218.      };
  219.   fractpart = 0.0;
  220.   divisor = 1.0;
  221.   if (ch == '.')
  222.      {
  223.        ch = readch();
  224.        while (ch >= '0' && ch <= '9')
  225.           {
  226.             fractpart = fractpart * 10.0 + (ch - '0');
  227.             divisor = divisor * 10.0;
  228.             ch = readch();
  229.           };
  230.      };
  231.   bufferptr = bufferptr - 1; /* unget the character */
  232.   number = sign * (((double) intpart) +
  233.                   ((double) fractpart) / ((double) divisor));
  234.   if (op == GT && number > min) return(number);
  235.   else if (op == GE && number >= min) return(number);
  236.   else
  237.      {
  238.        printf("erroneous value: %lf",number);
  239.        if (data == stdin) putchar('\n');
  240.        else printf(" in %c command\n",command);
  241.        readerror = 1;
  242.        return(0.0);
  243.      };
  244. }
  245.  
  246. WTTYPE rdr(op,min,command) /* reads double real numbers and converts */
  247. int op;                    /* them to 16-bit integers if necessary */
  248. double min;
  249. int command;
  250. {
  251.   double x;
  252.   WTTYPE ix;
  253.  
  254.   x = readreal(op,min,command);
  255.   if (readerror == 1) return(0);
  256.   ix = scale(x);
  257.   if (readerror == 1) return(0);
  258.   return(ix);
  259. }
  260.  
  261. double readchar()   /* reads data in compressed format */
  262. {
  263.   readerror = 0;
  264.   ch = readch();
  265.   do {
  266.              switch (ch) {
  267.   case '\n':
  268.   case ' ': ch = readch();
  269.             break;
  270.   case '1': return(1.0);
  271.   case '0': return(0.0);
  272.   case '?': return(unscale(qmark));
  273.   case '*': do {ch = readch();} while(ch != '\n');
  274.             break;
  275.   case 'h': return(unscale(HCODE));
  276.   case 'i': if (nlayers >= 3) return(unscale(ICODE));
  277.   case 'j': if (nlayers >= 4) return(unscale(JCODE));
  278.   case 'k': if (nlayers >= 5) return(unscale(KCODE));
  279.   default:  texterror();
  280.             readerror = 1;
  281.             return(0.0);
  282.           }; /* end switch */
  283.   } while (0 == 0);
  284. }
  285.  
  286. void printoutunits(layer,printerr)  /* prints values of units */
  287. LAYER *layer;
  288. int printerr;
  289. {
  290.  double error, e;
  291.  int counter, i;
  292.  UNIT *u;
  293.  WTTYPE upper, middle, diff;
  294.  PATNODE *target;
  295.  
  296.  upper = scale(1.0) - toler; /* compute whether needed or not */
  297.  middle = scale(0.5);
  298.  
  299.  u = (UNIT *) layer->units;
  300.  if (layer == last) target = (PATNODE *) last->currentpat->pats;
  301.  counter = 0;
  302.  i = 1;
  303.  if (printerr == 0) printf("    ");
  304.  while (u != NULL)
  305.     {
  306.       counter = counter + 1;
  307.       if (outformat == 'r')
  308.         {
  309.           printf("%5.2lf ",unscale(u->oj));
  310.           if (format[i] == counter)
  311.              {
  312.                printf("\n    ");
  313.                if (i < maxformat - 1) i = i + 1;
  314.              }
  315.          }
  316.       else if (outformat == 'a' && layer == last)
  317.          {
  318.            diff = target->val - u->oj;
  319.            if (diff < 0) diff = -diff;
  320.            if (diff < toler) putchar('c');
  321.            else if (u->oj > upper) putchar('1');
  322.            else if (u->oj < toler) putchar('0');
  323.            else if (u->oj > target->val) putchar('^');
  324.            else putchar('v');
  325.            if (format[i] == counter)
  326.               {
  327.                 putchar(' ');
  328.                 if (i < maxformat - 1) i = i + 1;
  329.               }
  330.          }
  331.       else 
  332.          {
  333.            if (u->oj > upper) putchar('1');
  334.            else if (u->oj > middle) putchar('^');
  335.            else if (u->oj < toler) putchar('0');
  336.            else putchar('v');
  337.            if (format[i] == counter)
  338.               {
  339.                 putchar(' ');
  340.                 if (i < maxformat - 1) i = i + 1;
  341.               }
  342.          }
  343.       u = u->next;
  344.       if (layer == last) target = target->next;
  345.     };
  346.  if (printerr == 1)
  347.     {
  348.       error = 0.0;
  349.       u = (UNIT *) layer->units;
  350.       target = (PATNODE *) last->currentpat->pats;
  351.       while (u != NULL)
  352.          {
  353.            e = unscale(target->val - u->oj);
  354.            error = error + e * e;
  355.            u = u->next;
  356.            target = target->next;
  357.          };
  358.        printf(" (%7.5lf)",error);
  359.     };
  360.  printf("\n");
  361. }
  362.  
  363. void wrb(wtfile,value,wtsize)
  364. FILE *wtfile;
  365. WTTYPE value;
  366. int wtsize;
  367. {
  368.   int i;
  369.   unsigned char *charptr, ch2;
  370.  
  371.   charptr = (unsigned char *) &value;
  372.   for (i=1;i<=wtsize;i++)
  373.      {
  374.        ch2 = *charptr;
  375.        putc(ch2,wtfile);
  376.        charptr++;
  377.      };
  378. }
  379.  
  380. void saveweights()    /* saves weights on the file weights */
  381. {
  382.   FILE *weights;
  383.   UNIT *u;
  384.   LAYER *layer;
  385.   WTNODE *w;
  386.   WTTYPE wvalue, evalue, dvalue;
  387.  
  388.   weights = fopen("weights","w");
  389.   fprintf(weights,"%d%c",totaliter,wtformat);
  390.   if (wtformat == 'b' || wtformat == 'B') fprintf(weights,"%1d",WTSIZE);
  391.   fprintf(weights,"   file = %s\n",datafilename);
  392.   layer = start->next;
  393.   while (layer != NULL)
  394.      {
  395.        u = (UNIT *) layer->units;
  396.        while (u != NULL)
  397.           {
  398.             w = (WTNODE *) u->wtlist;
  399.             while (w != NULL)
  400.                {
  401. #ifdef SYMMETRIC
  402.                  wvalue = *(w->weight);
  403.                  evalue = *(w->eta);
  404.                  dvalue = *(w->olddw);
  405. #else
  406.                  wvalue = w->weight;
  407.                  evalue = w->eta;
  408.                  dvalue = w->olddw;
  409. #endif
  410.                  if (wtformat == 'r' || wtformat == 'R')
  411.                     {
  412.                       fprintf(weights,"%16.10lf",unscale(wvalue));
  413.                       if (wtformat == 'R')
  414.                          {
  415.                            fprintf(weights," %16.10lf",unscale(evalue));
  416.                            fprintf(weights," %16.10lf",unscale(dvalue));
  417.                          };
  418.                       putc('\n',weights);
  419.                     }
  420.                  else  /* binary format; uses the least space */
  421.                     {
  422.                       wrb(weights,wvalue,WTSIZE);
  423.                       if (wtformat == 'B')
  424.                          {
  425.                            wrb(weights,evalue,WTSIZE);
  426.                            wrb(weights,dvalue,WTSIZE);
  427.                          };
  428.                     };
  429.                  w = w->next;
  430.                };
  431.             u = u->next;
  432.           };
  433.         layer = layer->next;
  434.       };
  435.   fflush(weights);
  436.   close(weights);
  437.   lastsave = totaliter;
  438. }
  439.  
  440. WTTYPE rdb(wtfile,wtsize) /* read binary and convert between sizes */
  441. FILE *wtfile;
  442. int wtsize;
  443. {
  444.   int i;
  445.   double value;
  446.   short ivalue;
  447.   unsigned char *charptr;
  448.  
  449.   if (wtsize == 2) charptr = (unsigned char *) &ivalue;
  450.   else charptr = (unsigned char *) &value;
  451.   for (i=1;i<=wtsize;i++)
  452.      {
  453.        *charptr = (unsigned char) getc(wtfile);
  454.        charptr++;
  455.      };
  456.   if (WTSIZE == 2 && wtsize == 2) return(ivalue);
  457.   else if (WTSIZE == 2 && wtsize == 8) return(scale(value));
  458.   else if (WTSIZE == 8 && wtsize == 8) return(value);
  459.   else if (WTSIZE == 8 && wtsize == 2) return(ivalue / 1024.0);
  460. }
  461.  
  462. void restoreweights()    /* restore weights from the file weights */
  463. {
  464.   FILE *weights;
  465.   UNIT *u;
  466.   LAYER *layer;
  467.   WTNODE *w;
  468.   int ch2, fileformat;
  469.   WTTYPE wvalue, evalue, dvalue;
  470.   double temp;
  471.   int wtsize;
  472.  
  473.   weights = fopen("weights","r");
  474.   if (weights == NULL)
  475.      {
  476.        printf("cannot open file weights\n");
  477.        return;
  478.      };
  479.   fscanf(weights,"%d",&totaliter);
  480.   fileformat = getc(weights);
  481.   if (fileformat != wtformat)
  482.      printf("caution: weight format mismatch\n");
  483.   if (fileformat == 'b' || fileformat == 'B')
  484.      {
  485.        wtsize = getc(weights) - '0';
  486.        if (WTSIZE != wtsize)
  487.           printf("caution: weight sizes mismatched\n");
  488.      }
  489.   else wtsize = WTSIZE;
  490.   ch2 = getc(weights);  /* skip over the file name */
  491.   while (ch2 != '\n') ch2 = getc(weights);
  492.   layer = start->next;
  493.   while (layer != NULL)
  494.      {
  495.        u = (UNIT *) layer->units;
  496.        while (u != NULL)
  497.           {
  498.             w = (WTNODE *) u->wtlist;
  499.             while (w != NULL)
  500.                {
  501.                  if (fileformat == 'r' || fileformat == 'R')
  502.                     {
  503.                       fscanf(weights,"%lf",&temp);
  504.                       wvalue = scale(temp);
  505.                       if (fileformat == 'R')
  506.                          {
  507.                            fscanf(weights,"%lf",&temp);
  508.                            evalue = scale(temp);
  509.                            fscanf(weights,"%lf",&temp);
  510.                            dvalue = scale(temp);
  511.                          };
  512.                      }
  513.                  else
  514.                     {
  515.                       wvalue = rdb(weights,wtsize);
  516.                       if (fileformat == 'B')
  517.                          {
  518.                            evalue = rdb(weights,wtsize);
  519.                            dvalue = rdb(weights,wtsize);
  520.                          };
  521.                     };
  522. #ifdef SYMMETRIC
  523.                  *(w->weight) = wvalue;
  524.                  if (fileformat == 'R' || fileformat == 'B')
  525.                     {
  526.                       *(w->olddw) = dvalue;
  527.                       *(w->eta) = evalue;
  528.                     }
  529.                  else *(w->olddw) = 0;
  530. #else
  531.                  w->weight = wvalue;
  532.                  if (fileformat == 'R' || fileformat == 'B')
  533.                     {
  534.                       w->olddw = dvalue;
  535.                       w->eta = evalue;
  536.                     }
  537.                  else w->olddw = 0;
  538. #endif
  539.                  w = w->next;
  540.                };
  541.             u = u->next;
  542.           };
  543.         layer = layer->next;
  544.       };
  545.    close(weights);
  546. }
  547.  
  548. void printweights(u)   /* print the weights leading into unit u */
  549. UNIT *u;
  550.  
  551. {WTNODE *w;
  552.  UNIT *bunit;
  553.  WTTYPE value;
  554. #ifdef INTEGER
  555.  int sum, input;
  556. #else
  557.  double sum, input;
  558. #endif
  559.  w = (WTNODE *) u->wtlist;
  560.  sum = 0;
  561.  printf("layer unit  unit value     weight         input from unit\n");
  562.  while (w != NULL)
  563.     {
  564.       bunit = (UNIT *) w->backunit;
  565. #ifdef SYMMETRIC
  566.       value = *(w->weight);
  567. #else
  568.       value = w->weight;
  569. #endif
  570.       input = value * bunit->oj;
  571. #ifdef INTEGER
  572.       input = input / 1024;
  573. #endif
  574.       sum = sum + input;
  575.       printf("%3d   ",bunit->layernumber);
  576.       if (bunit->unitnumber == 32767) printf("   t ");
  577.          else printf("%4d ",bunit->unitnumber);
  578.       printf("%10.5lf  %10.5lf  ",unscale(bunit->oj),unscaleint(value));
  579.       printf("%18.5lf\n",unscaleint(input));
  580.       w = w->next;
  581.     };
  582.  printf("                                      ");
  583.  printf("sum = %9.5lf\n\n",unscaleint(sum));
  584. }
  585.  
  586. void help()
  587. {
  588.   printf("\n");
  589.   ch = readch();
  590.   while (ch == ' ' && ch != '\n') ch = readch();
  591.           switch(ch) {
  592. default : printf("for help type h followed by letter of command\n");
  593.           break;
  594. case '?': printf("? prints program status and parameters.\n");
  595.           break;
  596. case '*': printf("* at the beginning of a line makes the line a");
  597.           printf(" comment.\n");
  598.           break;
  599. case '!': printf("Enter UNIX commands after the !.\n");
  600.           break;
  601. case 'A': printf("A is used to set the details of the algorithm. ");
  602.           printf("One or more\nof the following commands can go on ");
  603.           printf("the same line as the 'A':\n\n");
  604.           printf("a p sets the piecewise linear activation function\n");
  605.           printf("a s sets the smooth activation function (rbp only).");
  606.           printf("\n\nb + will backpropagate errors");
  607.           printf(" even when a unit is close to it's target.\n");
  608.           printf("b - will not backpropagate errors when a");
  609.           printf(" unit is close to it's target.\n\n");
  610.           printf("D <real> will set the sharpness of the sigmoid to");
  611.           printf(" <real>.\n\n");
  612.           printf("d d will use the derivative from the ");
  613.           printf("differential step size algorithm.\n");
  614.           printf("d f uses Fahlman's derivative.\n");
  615.           printf("d o uses the original derivative.\n\n");
  616.           printf("l <real> limits the weights to between +<real> ");
  617.           printf("and -<real>.  The default\n         is to not check");
  618.           printf(".  To reset to not check, use l 0.\n\n");
  619.           printf("s <int> will skip patterns that have been learned");
  620.           printf(" for <int> iterations.\n\n");
  621.           printf("u c will use the continuous update method.\n");
  622.           printf("u C will use the continuous update method with the");
  623.           printf(" differential step size etas.\n");
  624.           printf("u d will use the differential step size update.\nu ");
  625.           printf("j will use Jacob's delta-bar delta update method.\n");
  626.           printf("u o will use the original weight update method.\n");
  627.           break;
  628. case 'a': printf("a <real> sets the momentum parameter, alpha, to");
  629.           printf(" <real>.\n");
  630.           break;
  631. case 'b': printf("b <int1> <int2> ... <int10> puts a carriage return");
  632.           printf(" after each <inti>\nvalues when the output format");
  633.           printf(" is real and inserts a blank after each <inti>\n");
  634.           printf("value if the format is condensed.\n");
  635.           break;
  636. case 'C': printf("C clears the network and other relevant parameters");
  637.           printf(" so the problem can be re-run\nwith different");
  638.           printf(" initial weights.  Added hidden units are not");
  639.           printf(" removed.\n");
  640.           break;
  641.  
  642. #ifndef SYMMETRIC
  643. case 'c': printf("c <int1> <int2> <int3> <int4>\n");
  644.           printf("Adds a connection from layer <int1> unit <int2>\n");
  645.           printf("to layer <int3> unit <int4>.\n");
  646.           break;
  647. #endif
  648.  
  649. case 'E': printf("E1 echos input; E0 turns off echo of input.\n");
  650.           break;
  651. case 'e': printf("e <real1> <real2> sets eta, the learning rate, to");
  652.           printf(" <real1> and if\n");
  653.           printf("<real2> is present, eta2 of the differential");
  654.           printf(" step size algorithm\nis set to <real2>.  If ");
  655.           printf("<real2> is not present, eta2 = eta / 10.\n");
  656.           break;
  657. case 'f': printf("f is used to set the input and output formats for");
  658.           printf(" data.\nOne or more of the following commands can");
  659.           printf(" go on the line:\n\n");
  660.           printf("i c will read values in patterns as compressed.\n");
  661.           printf("i r will read values in patterns are reals.\n\n");
  662.           printf("o a will write node values as analog compressed.\n");
  663.           printf("o c will write node values as compressed.\n");
  664.           printf("o r will write node values as real.\n\n");
  665.           printf("s + will summarize learning status instead of");
  666.           printf(" listing each pattern.\n");
  667.           printf("s - will not summarize learning status and will");
  668.           printf(" list each pattern.\n\n");
  669.           printf("w b will write the weights to the file weights as");
  670.           printf(" binary values.\n");
  671.           printf("w B will write the weights and weight changes and");
  672.           printf(" etas as binary.\n");
  673.           printf("w r will write the weights to the file weights as");
  674.           printf(" real values.\n");
  675.           printf("w R will write the weights and weight changes and");
  676.           printf(" etas as real values.\n");
  677.           break;
  678.  
  679. #ifndef SYMMETRIC
  680. case 'H': printf("H <int> <real> adds a hidden unit to layer <int>\n");
  681.           printf("Weights are initialized to between -<real> and");
  682.           printf(" <real>.\n");
  683.           break;
  684. #endif
  685.  
  686. case 'h': printf("h <letter> gives help for command <letter>.\n");
  687.           break;
  688. case 'i': printf("i <filename> takes commands from <filename>.\n");
  689.           break;
  690. case 'j': printf("j is used to set parameters for Jacob's");
  691.           printf(" delta-bar-delta method.\nOne or more of the");
  692.           printf(" following commands can go on the line:\n\n");
  693.           printf("d <real> sets the decay factor to <real>.\n");
  694.           printf("e <real> sets the initial eta value to <real>.\n");
  695.           printf("k <real> sets kappa to <real>.\n");
  696.           printf("m <real> limits the maximum value of each eta to");
  697.           printf(" <real>.\nt <real> sets theta to <real>.\n");
  698.           break;
  699. case 'k': printf("k <real1> <real2> decreases all the weights in the ");
  700.           printf("network whose values\nare greater than <real1> by a");
  701.           printf(" random amount between 0 and <real2>.\nWeights ");
  702.           printf("less than -<real1> are increased by an amount ");
  703.           printf("between 0 and <real2>.\nIf <real1> = 0.0, and a ");
  704.           printf("weight = 0.0 then the weight is changed to\na ");
  705.           printf("value between -<real2> and +<real2>.\n");
  706.           break;
  707. case 'l': printf("l <int> prints values of nodes on layer <int>.\n");
  708.           break;
  709. case 'm': printf("m <int1> <int2> ... <intn> makes a network with\n");
  710.           printf("<int1> units in the first layer, <int2> units in\n");
  711.           printf("the second layer, ... , <intn> units in the nth");
  712.           printf(" layer\n");
  713.           break;
  714. case 'n': printf("n <int> <in1> <out1> ... <ini> <outi> ... <inN> ");
  715.           printf("<outN>\nreplaces all patterns with <int> new ones");
  716.           printf(".\n<ini> patterns go on the input units.\n");
  717.           printf("<outi> patterns go on the output units.\n");
  718.           break;
  719. case 'o': printf("o a outputs node values in analog compressed form.");
  720.           printf("\no c outputs node values in compressed form.\n");
  721.           printf("o r outputs node values as double.\n");
  722.           break;
  723. case 'P': printf("P lists the outputs for all patterns.\n");
  724.           printf("P <int> gives the output for pattern <int>.\n");
  725.           break;
  726. case 'p': printf("p <pat> submits the pattern, <pat>, to the input");
  727.           printf(" units.\n");
  728.           break;
  729. case 'Q': printf("Q <real> sets the value of ? in compressed input");
  730.           printf(" to be the value, <real>.\n");
  731.           break;
  732. case 'q': printf("q ends the program.\n");
  733.           break;
  734. case 'R': printf("R reloads weights from the file weights.\n");
  735.           break;
  736. case 'r': printf("r <int1> <int2> runs <int1> iterations thru the ");
  737.           printf("patterns.  If <int2> is\npresent, the patterns are ");
  738.           printf("printed (or summarized) every <int2> iterations.\n");
  739.           break;
  740. case 'S': printf("S <int> saves the weights on the file ");
  741.           printf("weights every <int> iterations.\nS saves the ");
  742.           printf("weights immediately.\n");
  743.           break;
  744. case 's': printf("s <int> sets the random number seed to <int>.\n");
  745.           break;
  746.  
  747. #ifdef SYMMETRIC
  748. case 'T': printf("T <real> freezes all threshold weights at <real>.\n");
  749.           break;
  750. #endif
  751.  
  752. case 't': printf("t <real> sets <real> as the tolerance used in ");
  753.           printf("printing compressed values\nand in checking for");
  754.           printf(" complete learning.\n");
  755.           break;
  756. #ifndef SYMMETRIC
  757. case 'W': printf("W <real> removes links whose weights are less than ");
  758.           printf("the absolute value\nof <real>, except links to ");
  759.           printf("threshold units are not removed.\n");
  760.           break;
  761. #endif
  762.  
  763. case 'w': printf("w <int1> <int2>  ");
  764.           printf("prints weights into unit <int2> in layer <int1>.\n");
  765.           break;
  766. case 'x': printf("x <int1> <in1> <out1> ... <ini> <outi> ... <inN>");
  767.           printf(" <outN>\nadds the extra <int1> patterns.\n");
  768.           printf("<in1> patterns go on the input units.\n");
  769.           printf("<out1> patterns go on the output units.\n");
  770.           break;
  771.        }; /* end switch */
  772.   putchar('\n');
  773. }
  774.