home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / backprop / part03 < prev    next >
Encoding:
Text File  |  1992-09-01  |  40.8 KB  |  1,384 lines
  1. Newsgroups: comp.sources.misc
  2. From: drt@chinet.chi.il.us (Donald Tveter)
  3. Subject:  v31i131:  backprop - Fast Backpropagation, Part03/04
  4. Message-ID: <1992Sep2.180724.28109@sparky.imd.sterling.com>
  5. X-Md4-Signature: ff438e5ac73adaf048e29ff6a68ec60f
  6. Date: Wed, 2 Sep 1992 18:07:24 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: drt@chinet.chi.il.us (Donald Tveter)
  10. Posting-number: Volume 31, Issue 131
  11. Archive-name: backprop/part03
  12. Supersedes: backprop: Volume 28, Issue 63-66
  13. Environment: UNIX, DOS
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then unpack
  17. # it by saving it into a file and typing "sh file".  To overwrite existing
  18. # files, type "sh file -c".  You can also feed this as standard input via
  19. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  20. # will see the following message at the end:
  21. #        "End of archive 3 (of 4)."
  22. # Contents:  io.c ibp.h rbp.h makefile makereal makefile.unx
  23. # Wrapped by drt@chinet on Sat Jun 13 14:57:16 1992
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. if test -f 'io.c' -a "${1}" != "-c" ; then 
  26.   echo shar: Will not clobber existing file \"'io.c'\"
  27. else
  28. echo shar: Extracting \"'io.c'\" \(25359 characters\)
  29. sed "s/^X//" >'io.c' <<'END_OF_FILE'
  30. X/* ************************************************** */
  31. X/* file io.c:  contains most input/output functions   */
  32. X/*                                                    */
  33. X/* Copyright (c) 1990, 1991, 1992 by Donald R. Tveter */
  34. X/*                                                    */
  35. X/* ************************************************** */
  36. X
  37. X#include <stdio.h>
  38. X#ifdef INTEGER
  39. X#include "ibp.h"
  40. X#else
  41. X#include "rbp.h"
  42. X#endif
  43. X
  44. X#ifdef UNIX
  45. X#include <malloc.h>
  46. X#define WRITEBIN "w"
  47. X#define READBIN "r"
  48. X#else
  49. X#include <stdlib.h>
  50. X#define WRITEBIN "wb"
  51. X#define READBIN "rb"
  52. X#endif
  53. X
  54. Xextern char buffer[buffsize], copyflag, *datafilename, echo, outformat;
  55. Xextern char outstr[OUTSTRSIZE], *wtfile, wtformat;
  56. Xextern int bufferend, bufferptr, filestackptr, format[maxformat];
  57. Xextern FILE *data, *filestack[];
  58. Xextern LAYER *start;
  59. Xextern int lastsave, pagesize, readerror, readingpattern, totaliter;
  60. Xextern INT32 lineno;
  61. Xextern short nlayers;
  62. Xextern WTTYPE qmark, toler;
  63. Xextern FILE *copy;
  64. X
  65. XWTTYPE error;
  66. Xint bad;
  67. X
  68. X#ifdef INTEGER
  69. X
  70. Xshort scale(x)     /* returns x as a scaled 16-bit value */
  71. XREAL x;
  72. X{
  73. X short s;
  74. X
  75. Xif (x > 31.999 || x < -32.0)
  76. X {
  77. X  sprintf(outstr,"magnitude of %f is too large for the integer",x);
  78. X  pg(outstr);
  79. X  pg(" representation\n");
  80. X  readerror = 1;
  81. X  if (x > 31.999) return(MAXSHORT); else return(MINSHORT);
  82. X };
  83. Xif (x > 0.0) s = x * 1024 + 0.5;
  84. Xelse s = x * 1024 - 0.5;
  85. Xif (x != 0.0 && s == 0)
  86. X {
  87. X  sprintf(outstr,"warning:  magnitude of %f is too small for",x);
  88. X  pg(outstr);
  89. X  pg(" the integer representation\n");
  90. X  return(0);
  91. X };
  92. Xreturn(s);
  93. X}
  94. X
  95. XREAL unscale(x)  /* returns the REAL value of short x */
  96. Xshort x;
  97. X{ return((REAL) x / 1024.0); }
  98. X
  99. XREAL unscaleint(x)  /* returns the REAL value of INT32 x */
  100. XINT32 x;
  101. X{ return((REAL) x / 1024.0); }
  102. X
  103. X#endif
  104. X
  105. Xint pushfile(filename)
  106. Xchar *filename;
  107. X{
  108. XFILE *file;
  109. X
  110. Xbufferptr = 0;
  111. Xbufferend = 0;
  112. Xbuffer[0] = '\n';
  113. Xfile = fopen(filename,"r");
  114. Xif (file == NULL)
  115. X {
  116. X  sprintf(outstr,"cannot open:, %s\n",filename); pg(outstr);
  117. X  return(0);
  118. X };
  119. Xfilestackptr = filestackptr + 1;
  120. Xif (filestackptr > 3)
  121. X {
  122. X  pg("can't stack up any more files\n");
  123. X  filestackptr = filestackptr - 1;
  124. X  fclose(file);
  125. X  return(0);
  126. X };
  127. Xfilestack[filestackptr] = file;
  128. Xdata = file;
  129. Xreturn(1);
  130. X} 
  131. X
  132. Xvoid popfile()
  133. X{
  134. Xbufferptr = 0;
  135. Xbufferend = 0;
  136. Xbuffer[0] = '\n';
  137. Xif (filestackptr > 0)
  138. X {
  139. X  fclose(data);
  140. X  filestackptr = filestackptr - 1;
  141. X }
  142. Xelse pg("\nunexpected EOF:  to quit the program, type q\n");
  143. Xdata = filestack[filestackptr];
  144. X}
  145. X
  146. Xint readch() /* returns the next character in the input buffer */
  147. X{ 
  148. X int i, ch2;
  149. X char smallbuffer[2];
  150. X
  151. Xif (bufferptr > bufferend) /* then read next line into buffer */
  152. X {
  153. X  ch2 = getc(data);
  154. X  if (ch2 == EOF) return(ch2);
  155. X  i = 0;
  156. X  while(ch2 != '\n' && i < buffsize)
  157. X   {
  158. X#ifdef UNIX
  159. X    if (ch2 == 13) ch2 = ' '; /* turn a ctrl-M into a blank */
  160. X#endif
  161. X    buffer[i] = ch2;
  162. X    i = i + 1;
  163. X    ch2 = getc(data);
  164. X   };
  165. X  if (i == buffsize) pg("line too long\n");
  166. X  buffer[i] = '\n';
  167. X  bufferend = i;
  168. X  bufferptr = 0;
  169. X  if (echo == '+') for(i = 0; i <= bufferend; i++) putchar(buffer[i]);
  170. X  if (copy && ((data == stdin) || (echo == '+')))
  171. X   for (i=0;i<=bufferend;i++) putc(buffer[i],copy);
  172. X }
  173. Xch2 = buffer[bufferptr];
  174. Xbufferptr = bufferptr + 1;
  175. Xreturn(ch2);
  176. X}
  177. X
  178. Xvoid texterror()
  179. X{
  180. Xint ch2;
  181. Xpg("unexpected text:  ");
  182. Xpg(&buffer[bufferptr-1]);
  183. Xbufferptr = buffsize + 1;
  184. X}
  185. X
  186. Xchar *readstr()
  187. X{
  188. Xshort i,start,end;
  189. Xchar *addr, *addr2;
  190. Xi = bufferptr;
  191. Xwhile (buffer[i] == ' ') i = i + 1;
  192. Xstart = i;
  193. Xwhile (buffer[i] != ' ' && buffer[i] != '\n') i = i + 1;
  194. Xend = i-1;
  195. Xaddr = (char *) malloc((int) end-start+2);
  196. Xaddr2 = addr;
  197. Xfor (i=start;i<=end;i++) *addr++ = buffer[i];
  198. Xbufferptr = end + 1;
  199. X*addr = '\0';
  200. Xreturn(addr2);
  201. X}
  202. X
  203. Xint scanfordigit()
  204. X{
  205. Xint sign, ch2;
  206. X
  207. Xsign = 1;
  208. X
  209. Xrestart:
  210. Xdo ch2 = readch(); while (ch2 == ' ' || ch2 == '\n');
  211. Xif (ch2 >= '0' && ch2 <= '9')
  212. X {
  213. X  bufferptr = bufferptr - 1;
  214. X  return(sign);
  215. X };
  216. Xif (ch2 >= 'h' && ch2 <= 'k')
  217. X {
  218. X  bufferptr = bufferptr - 1;
  219. X  return(0);
  220. X };
  221. X          switch (ch2) {
  222. Xcase EOF: readerror = 2;
  223. X          return(0);
  224. Xcase '*': while (ch2 != '\n') ch2 = readch();
  225. X          goto restart;
  226. Xcase '-': sign = -sign;
  227. X          goto restart;
  228. Xcase '?': bufferptr = bufferptr - 1;
  229. X          return(0);
  230. Xdefault:  readerror = 1;
  231. X          return(0);
  232. X          };
  233. X}
  234. X
  235. Xint readint(min,max,command)
  236. Xint min, max;
  237. Xchar command;
  238. X{
  239. Xint sign, number, ch2;
  240. X
  241. Xreaderror = 0;
  242. Xsign = scanfordigit();
  243. Xif (readerror)
  244. X {
  245. X  if (readerror == 1) texterror();
  246. X  return(0);
  247. X };
  248. Xnumber = 0;
  249. Xdo ch2 = readch(); while (ch2 == ' ');
  250. Xwhile (ch2 >= '0' && ch2 <= '9')
  251. X {
  252. X  number = number * 10 + (ch2 - '0');
  253. X  ch2 = readch();
  254. X };
  255. Xbufferptr = bufferptr - 1;
  256. Xnumber = sign * number;
  257. Xif (number < min || number > max)
  258. X {
  259. X  sprintf(outstr,"out of range value: %d",number); pg(outstr);
  260. X  if (data == stdin) pg("\n");
  261. X  else {sprintf(outstr," in %c command\n",command); pg(outstr);};
  262. X  readerror = 1;
  263. X };
  264. Xreturn(number);
  265. X}
  266. X
  267. XREAL readreal(op,min,command)
  268. Xint op;
  269. XREAL min;
  270. Xint command;
  271. X{
  272. XREAL number, fractpart, divisor, intpart, sign;
  273. Xint ch2;
  274. X
  275. Xreaderror = 0;
  276. Xsign = (REAL) scanfordigit();
  277. Xif (readerror || (sign == 0 && !readingpattern))
  278. X {
  279. X  if (readerror == 1) texterror();
  280. X  return(0);
  281. X };
  282. Xch2 = readch();
  283. Xif (ch2 == 'h' && readingpattern) return(unscale(HCODE));
  284. Xelse if (ch2 == 'i' && readingpattern && nlayers >= 3)
  285. X  return(unscale(ICODE));
  286. Xelse if (ch2 == 'j' && readingpattern && nlayers >= 4)
  287. X  return(unscale(JCODE));
  288. Xelse if (ch2 == 'k' && readingpattern && nlayers >= 5)
  289. X  return(unscale(KCODE));
  290. Xelse if (ch2 == '?' && readingpattern)
  291. X  return(unscale(qmark));
  292. Xintpart = 0.0;
  293. Xwhile (ch2 >= '0' && ch2 <= '9')
  294. X {
  295. X  intpart = 10.0 * intpart + (ch2 - '0');
  296. X  ch2 = readch();
  297. X };
  298. Xfractpart = 0.0;
  299. Xdivisor = 1.0;
  300. Xif (ch2 == '.')
  301. X {
  302. X  ch2 = readch();
  303. X  while (ch2 >= '0' && ch2 <= '9')
  304. X   {
  305. X    fractpart = fractpart * 10.0 + (ch2 - '0');
  306. X    divisor = divisor * 10.0;
  307. X    ch2 = readch();
  308. X   };
  309. X };
  310. Xbufferptr = bufferptr - 1;
  311. Xnumber = sign * (((REAL) intpart) +
  312. X                ((REAL) fractpart) / ((REAL) divisor));
  313. Xif (op == GT && number > min) return(number);
  314. Xelse if (op == GE && number >= min) return(number);
  315. Xelse
  316. X {
  317. X  sprintf(outstr,"erroneous value: %f",number); pg(outstr);
  318. X  if (data == stdin) pg("\n");
  319. X  else {sprintf(outstr," in %c command\n",command); pg(outstr);};
  320. X  readerror = 1;
  321. X  return(0.0);
  322. X };
  323. X}
  324. X
  325. XWTTYPE rdr(op,min,command) /* reads REAL real numbers and converts */
  326. Xint op;                    /* them to 16-bit integers if necessary */
  327. XREAL min;
  328. Xint command;
  329. X{
  330. XREAL x;
  331. XWTTYPE ix;
  332. X 
  333. Xx = readreal(op,min,command);
  334. Xif (readerror) return(0);
  335. Xix = scale(x);
  336. Xif (readerror) return(0);
  337. Xreturn(ix);
  338. X}
  339. X
  340. XREAL readchar()   /* reads data in compressed format */
  341. X{
  342. Xint ch2;
  343. Xreaderror = 0;
  344. Xch2 = readch();
  345. Xdo {
  346. X          switch (ch2) {
  347. Xcase '\n':
  348. Xcase ' ': ch2 = readch();
  349. X          break;
  350. Xcase '1': return(1.0);
  351. Xcase '0': return(0.0);
  352. Xcase '?': return(unscale(qmark));
  353. Xcase '*': do ch2 = readch(); while(ch2 != '\n');
  354. X          break;
  355. Xcase 'h': return(unscale(HCODE));
  356. Xcase 'i': if (nlayers >= 3) return(unscale(ICODE));
  357. Xcase 'j': if (nlayers >= 4) return(unscale(JCODE));
  358. Xcase 'k': if (nlayers >= 5) return(unscale(KCODE));
  359. Xcase EOF: readerror = 2;
  360. X          return(0.0);
  361. Xdefault:  texterror();
  362. X          readerror = 1;
  363. X          return(0.0);};
  364. X} while (0 == 0);
  365. X}
  366. X
  367. Xint pg(str) /* paging and making a copy function */
  368. Xchar *str;
  369. X{
  370. Xchar *ch3,action,cr;
  371. Xint copying;
  372. X
  373. Xcopying = copyflag == '+';
  374. Xch3 = str;
  375. Xwhile (*ch3 != '\0')
  376. X   {
  377. X     if (*ch3 == '\n')
  378. X        {
  379. X          putchar('\n');
  380. X          if (copying) putc('\n',copy);
  381. X          lineno = lineno + 1;
  382. X          if (pagesize && lineno % pagesize == 0)
  383. X             {
  384. X               putchar(':');
  385. X               action = getchar();
  386. X               if (action == 'q')
  387. X                  {
  388. X                    cr = getchar();
  389. X                    return(action);
  390. X                  };
  391. X             }
  392. X        }
  393. X     else {putchar(*ch3); if (copying) putc(*ch3,copy); };
  394. X     ch3++;
  395. X   };
  396. Xreturn(0);
  397. X}
  398. X
  399. Xint printoutunits(printing,layer,printerr)  /* prints values of units */
  400. Xint printing;                               /* and computes errors */
  401. XLAYER *layer;
  402. Xint printerr;
  403. X{
  404. Xshort unitno, fmtbreaknum, maxval, maxunit;
  405. XUNIT *u;
  406. XWTTYPE upper, middle, diff;
  407. X
  408. Xif (printing)
  409. X {
  410. X  upper = scale(1.0) - toler;
  411. X  middle = scale(0.5);
  412. X  unitno = 0;
  413. X  fmtbreaknum = 1;
  414. X };
  415. Xbad = 0;
  416. Xmaxval = -scale(2.0);
  417. Xmaxunit = 0;
  418. Xerror = 0;
  419. Xu = (UNIT *) layer->units;
  420. Xwhile (u != NULL)
  421. X {
  422. X  diff = u->tj - u->oj;
  423. X  if (diff < 0) diff = -diff;
  424. X  if (diff >= toler) bad = 1;
  425. X  error = error +  diff;
  426. X  if (printing)
  427. X   {
  428. X    unitno = unitno + 1;
  429. X    if (outformat == 'r')
  430. X     {
  431. X      sprintf(outstr,"%6.3f ",unscale(u->oj)); pg(outstr);
  432. X      if (format[fmtbreaknum] == unitno)
  433. X       {
  434. X        if (pg("\n    ")) return(1);
  435. X        if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  436. X       }
  437. X     }
  438. X    else if (outformat == 'a' && printerr)
  439. X     {
  440. X      if (diff < toler) pg("c");
  441. X      else if (u->oj > upper) pg("1");
  442. X      else if (u->oj < toler) pg("0");
  443. X      else if (u->oj > u->tj) pg("^");
  444. X      else pg("v");
  445. X      if (format[fmtbreaknum] == unitno)
  446. X       {
  447. X        pg(" ");
  448. X        if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  449. X       }
  450. X     }
  451. X    else 
  452. X     {
  453. X      if (u->oj > upper) pg("1");
  454. X      else if (u->oj > middle) pg("^");
  455. X      else if (u->oj < toler) pg("0");
  456. X      else pg("v");
  457. X      if (format[fmtbreaknum] == unitno)
  458. X       {
  459. X        pg(" ");
  460. X        if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  461. X       }
  462. X     }
  463. X   };
  464. X  u = u->next;
  465. X };
  466. Xif (!printing) return(0);
  467. Xif (printerr) {sprintf(outstr," (%5.3f)",unscale(error)); pg(outstr);};
  468. Xif (printerr && !bad) pg(" ok");
  469. Xif (pg("\n")) return(1); else return(0);
  470. X}
  471. X
  472. Xvoid saveweights()    /* saves weights on the file weights */
  473. X{
  474. XUNIT *u;
  475. XLAYER *layer;
  476. XWTNODE *w;
  477. XWTTYPE wvalue, evalue, dvalue, svalue;
  478. Xint wtsize;
  479. XFILE *weights;
  480. X
  481. Xwtsize = WTSIZE;
  482. Xweights = fopen(wtfile,WRITEBIN);
  483. Xif (weights == NULL)
  484. X {
  485. X  sprintf(outstr,"cannot open: %s\n",wtfile); pg(outstr);
  486. X  return;
  487. X };
  488. Xfprintf(weights,"%d%c",totaliter,wtformat);
  489. Xif (wtformat == 'b' || wtformat == 'B') fprintf(weights,"%1d",WTSIZE);
  490. Xfprintf(weights,"   file = %s\r\n",datafilename);
  491. Xlayer = start->next;
  492. Xwhile (layer != NULL)
  493. X {
  494. X  u = (UNIT *) layer->units;
  495. X  while (u != NULL)
  496. X   {
  497. X    w = (WTNODE *) u->wtlist;
  498. X    while (w != NULL)
  499. X     {
  500. X#ifdef SYMMETRIC
  501. X      wvalue = *(w->weight);
  502. X      evalue = *(w->eta);
  503. X      dvalue = *(w->olddw);
  504. X      svalue = 0; /* not worth having in the symmetric version */
  505. X#else
  506. X      wvalue = w->weight;
  507. X      evalue = w->eta;
  508. X      dvalue = w->olddw;
  509. X      svalue = w->slope;
  510. X#endif
  511. X      if (wtformat == 'r' || wtformat == 'R')
  512. X       {
  513. X        fprintf(weights,"%16.10f",unscale(wvalue));
  514. X        if (wtformat == 'R')
  515. X         {
  516. X          fprintf(weights," %16.10f",unscale(evalue));
  517. X          fprintf(weights," %16.10f",unscale(dvalue));
  518. X         };
  519. X        fprintf(weights,"\r\n");
  520. X       }
  521. X      else  /* binary format; uses the least space */
  522. X       {
  523. X        fwrite((char *) &wvalue,wtsize,1,weights);
  524. X        if (wtformat == 'B')
  525. X         {
  526. X          fwrite((char *) &evalue,wtsize,1,weights);
  527. X          fwrite((char *) &dvalue,wtsize,1,weights);
  528. X         };
  529. X       };
  530. X      w = w->next;
  531. X     };
  532. X    u = u->next;
  533. X   };
  534. X  layer = layer->next;
  535. X };
  536. Xfflush(weights);
  537. Xfclose(weights);
  538. Xlastsave = totaliter;
  539. X}
  540. X
  541. XWTTYPE rdb(wtfile,wtsize) /* read binary and convert between sizes */
  542. XFILE *wtfile;
  543. Xint wtsize;
  544. X{
  545. Xint i, ch2;
  546. Xdouble dvalue;
  547. Xfloat fvalue;
  548. Xshort ivalue;
  549. Xunsigned char *charptr;
  550. X
  551. Xif (wtsize == 2) charptr = (unsigned char *) &ivalue;
  552. Xelse if (wtsize == 4) charptr = (unsigned char *) &fvalue;
  553. Xelse if (wtsize == 8) charptr = (unsigned char *) &dvalue;
  554. Xelse pg("bad weight size\n");
  555. Xfor (i=1;i<=wtsize;i++)
  556. X {
  557. X  ch2 = fgetc(wtfile);
  558. X  *charptr = (unsigned char) ch2;
  559. X  charptr++;
  560. X };
  561. Xif (WTSIZE == 2 && wtsize == 2) return(ivalue);
  562. Xelse if (WTSIZE == 2 && wtsize == 4) return(scale(fvalue));
  563. Xelse if (WTSIZE == 2 && wtsize == 8) return(scale(dvalue));
  564. Xelse if (WTSIZE == 4 && wtsize == 2) return(ivalue / 1024.0);
  565. Xelse if (WTSIZE == 4 && wtsize == 4) return(fvalue);
  566. Xelse if (WTSIZE == 4 && wtsize == 8) return((float) dvalue);
  567. Xelse if (WTSIZE == 8 && wtsize == 2) return(ivalue / 1024.0);
  568. Xelse if (WTSIZE == 8 && wtsize == 4) return((double) fvalue);
  569. Xelse if (WTSIZE == 8 && wtsize == 8) return(dvalue);
  570. X}
  571. X
  572. Xvoid restoreweights()    /* restore weights from the file weights */
  573. X{
  574. XFILE *weights;
  575. XUNIT *u;
  576. XLAYER *layer;
  577. XWTNODE *w;
  578. Xint ch2, fileformat, wtsize;
  579. XWTTYPE wvalue, evalue, dvalue, svalue;
  580. Xdouble temp;
  581. X
  582. Xweights = fopen(wtfile,READBIN);
  583. Xif (weights == NULL)
  584. X {
  585. X  pg("cannot open file weights\n");
  586. X  return;
  587. X };
  588. Xfscanf(weights,"%d",&totaliter);
  589. Xfileformat = getc(weights);
  590. Xif (fileformat != wtformat) pg("note: weight format mismatch\n");
  591. Xif (fileformat == 'b' || fileformat == 'B')
  592. X {
  593. X  wtsize = getc(weights) - '0';
  594. X  if (WTSIZE != wtsize) pg("note: weight sizes mismatched\n");
  595. X }
  596. Xelse wtsize = WTSIZE;
  597. Xdo ch2 = getc(weights); while (ch2 != '\n'); /* skip rest of line */
  598. Xlayer = start->next;
  599. Xwhile (layer != NULL)
  600. X {
  601. X  u = (UNIT *) layer->units;
  602. X  while (u != NULL)
  603. X   {
  604. X    w = (WTNODE *) u->wtlist;
  605. X    while (w != NULL)
  606. X     {
  607. X      if (fileformat == 'r' || fileformat == 'R')
  608. X       {
  609. X        fscanf(weights,"%lf",&temp);
  610. X        wvalue = scale((REAL) temp);
  611. X        if (fileformat == 'R')
  612. X         {
  613. X          fscanf(weights,"%lf",&temp);
  614. X          evalue = scale((REAL) temp);
  615. X          fscanf(weights,"%lf",&temp);
  616. X          dvalue = scale((REAL) temp);
  617. X         };
  618. X       }
  619. X      else
  620. X       {
  621. X        wvalue = rdb(weights,wtsize);
  622. X        if (fileformat == 'B')
  623. X         {
  624. X          evalue = rdb(weights,wtsize);
  625. X          dvalue = rdb(weights,wtsize);
  626. X         };
  627. X       };
  628. X#ifdef SYMMETRIC
  629. X      *(w->weight) = wvalue;
  630. X      if (fileformat == 'R' || fileformat == 'B')
  631. X       {
  632. X        *(w->olddw) = dvalue;
  633. X        *(w->eta) = evalue;
  634. X       }
  635. X      else *(w->olddw) = 0;
  636. X#else
  637. X      w->weight = wvalue;
  638. X      if (fileformat == 'R' || fileformat == 'B')
  639. X       {
  640. X        w->olddw = dvalue;
  641. X        w->eta = evalue;
  642. X        w->slope = svalue;
  643. X       }
  644. X      else w->olddw = 0;
  645. X#endif
  646. X      w = w->next;
  647. X     };
  648. X    u = u->next;
  649. X   };
  650. X  layer = layer->next;
  651. X };
  652. Xfclose(weights);
  653. X}
  654. X
  655. Xvoid printweights(u)   /* print the weights leading into unit u */
  656. XUNIT *u;
  657. X
  658. X{
  659. XWTNODE *w;
  660. XUNIT *bunit;
  661. XWTTYPE value;
  662. X#ifdef INTEGER
  663. XINT32 sum, input;
  664. X#else
  665. XREAL sum, input;
  666. X#endif
  667. X
  668. Xw = (WTNODE *) u->wtlist;
  669. Xsum = 0;
  670. Xpg("layer unit  unit value     weight         input from unit\n");
  671. Xwhile (w != NULL)
  672. X {
  673. X  bunit = (UNIT *) w->backunit;
  674. X#ifdef SYMMETRIC
  675. X  value = *(w->weight);
  676. X#else
  677. X  value = w->weight;
  678. X#endif
  679. X
  680. X#ifdef INTEGER
  681. X  input = (INT32) value * bunit->oj;
  682. X  input = input / 1024;
  683. X#else
  684. X  input = value * bunit->oj;
  685. X#endif
  686. X  sum = sum + input;
  687. X  sprintf(outstr,"%3d   ",bunit->layernumber); pg(outstr);
  688. X  if (bunit->unitnumber == 32767) pg("   t ");
  689. X  else {sprintf(outstr,"%4d ",bunit->unitnumber); pg(outstr);};
  690. X  sprintf(outstr,"%10.5f  %10.5f  ",unscale(bunit->oj),unscale(value));
  691. X  pg(outstr);
  692. X  sprintf(outstr,"%18.5f\n",unscaleint(input));
  693. X  if (pg(outstr)) return;
  694. X  w = w->next;
  695. X };
  696. Xpg("                                      ");
  697. Xsprintf(outstr,"sum = %9.5f\n\n",unscaleint(sum)); pg(outstr);
  698. X}
  699. X
  700. Xvoid help()
  701. X{
  702. Xint ch2;
  703. Xpg("\n");
  704. Xdo ch2 = readch(); while (ch2 == ' ' && ch2 != '\n');
  705. X        switch(ch2) {
  706. X
  707. Xdefault:
  708. Xpg("for help type h followed by the letter of the command\n");
  709. Xif (ch2 == '\n') bufferptr = bufferptr - 1;
  710. Xbreak;
  711. X
  712. Xcase '?':
  713. Xpg("? prints program status and parameters.\n");
  714. Xbreak;
  715. X
  716. Xcase '*':
  717. Xpg("* at the beginning of a line makes the line a comment.\n");
  718. Xbreak;
  719. X
  720. Xcase '!':
  721. Xpg("Enter system commands after the !.\n");
  722. Xbreak;
  723. X
  724. Xcase 'A':
  725. Xpg("A is used to set details of the algorithm.  One or more of \n");
  726. Xpg("the following commands can go on the same line as the 'A':\n\n");
  727. Xpg("a l sets the linear activation function.\n");
  728. Xpg("a p sets the piecewise linear activation function.\n");
  729. Xpg("a t sets the piecewise near tanh activation function.\n");
  730. X#ifndef INTEGER
  731. Xpg("a s sets the smooth activation function.\n");
  732. Xpg("a T sets the smooth near tanh activation function.\n");
  733. X#endif
  734. Xpg("\n");
  735. Xpg("b + will backpropagate errors even when a unit is close to ");
  736. Xpg("its target.\n");
  737. Xpg("b - will not backpropagate errors when a unit is close to its");
  738. Xpg(" target.\n\n");
  739. Xpg("D <real> will set the sharpness of the sigmoid to <real>.\n\n");
  740. Xpg("d d will use the derivatives from the differential step size");
  741. Xpg(" algorithm.\n");
  742. Xpg("d F uses Fahlman's derivative in the output layer.\n");
  743. Xpg("d f uses Fahlman's derivative in all layers.\n");
  744. Xpg("d o uses the original derivative.\n\n");
  745. Xpg("g <int> updates weights after every group of <int> patterns if <int> != 0.\n\n");
  746. Xpg("s <int> will skip for <int> iterations patterns that have been ");
  747. Xpg("learned.\n\n");
  748. Xpg("t <int> will take pattern <int> out of the training process.\n");
  749. Xpg("   To bring it back in, use t 0.\n\n");
  750. Xpg("u c gives the continuous update method.\n");
  751. X#ifndef SYMMETRIC
  752. Xpg("u d gives the delta-bar-delta update method.\n");
  753. X#endif
  754. Xpg("u p gives the periodic update method.\n");
  755. Xbreak;
  756. X
  757. Xcase 'a':
  758. Xpg("a <real> sets the momentum parameter, alpha, to <real>.\n");
  759. Xbreak;
  760. X
  761. Xcase 'B':
  762. Xpg("B <options> sets the following benchmarking options:\n\n");
  763. Xpg("g <int> sets <int> to be the goal for the number of");
  764. Xpg(" networks to converge.\n\n");
  765. Xpg("k <real> sets the range of the initial random");
  766. Xpg(" weights for each network.\n\n");
  767. Xpg("m <int> sets the maximum number of networks to try.\n\n");
  768. Xpg("r <int1> <int2> sets <int1> to be the maximum ");
  769. Xpg("number of iterations to run.\n  <int2>, if present,");
  770. Xpg(" sets the rate at which to sample the network.\n  ");
  771. Xpg("Using r in a B command will initiate benchmarking.\n\n");
  772. Xpg("t <int> will benchmark with pattern <int> removed");
  773. Xpg(" from the training set\n  and test it at the");
  774. Xpg(" sample rate given in the r command.\n");
  775. Xpg("t f <testfile> will test patterns on <testfile> at ");
  776. Xpg("the interval given for\n   the sample rate.\n");
  777. Xpg("t 0 turns off either type of testing.\n");
  778. Xbreak;
  779. X
  780. Xcase 'b':
  781. Xpg("b <int1> <int2> ... <int20> puts a carriage break");
  782. Xpg(" after each <inti>\nvalues when the output format");
  783. Xpg(" is real and inserts a blank after each <inti>\n");
  784. Xpg("value if the format is condensed.\n");
  785. Xbreak;
  786. X
  787. Xcase 'C':
  788. Xpg("C clears the network and other relevant parameters");
  789. Xpg(" so the problem can be re-run\nwith different");
  790. Xpg(" initial weights.  Added hidden units are not removed.\n");
  791. Xbreak;
  792. X
  793. X#ifndef SYMMETRIC
  794. Xcase 'c':
  795. Xpg("c <int1> <int2> <int3> <int4>  ");
  796. Xpg("Adds a connection from layer <int1> unit <int2>\n");
  797. Xpg("   to layer <int3> unit <int4>.\n");
  798. Xbreak;
  799. X#endif
  800. X
  801. Xcase 'd':
  802. Xpg("d is used to set parameters for the delta-bar-delta method.\n");
  803. Xpg("One or more of the following commands can go on the line:\n\n");
  804. Xpg("d <real> sets the decay factor to <real>.\n");
  805. Xpg("e <real> sets the initial eta value to <real>.\n");
  806. Xpg("k <real> sets kappa to <real>.\n");
  807. Xpg("m <real> limits the maximum value of each eta to <real>.\n");
  808. X#ifdef INTEGER
  809. Xpg("n <real> sets some noise (integer versions only).");
  810. Xpg("   Try <real> around 0.005.\n");
  811. X#endif
  812. Xpg("t <real> sets the theta parameter to <real>.\n");
  813. Xbreak;
  814. X
  815. Xcase 'e':
  816. Xpg("e <real1> <real2> sets eta, the learning rate for the top layer");
  817. Xpg(" to <real1>\n   and eta2 for the lower layers to <real2>.  If ");
  818. Xpg("<real2> is not present,\n   eta2 is set to <real1>.\n");
  819. Xbreak;
  820. X
  821. Xcase 'f':
  822. Xpg("f is used to set the input and output formats for data.\nOne ");
  823. Xpg("or more of the following commands can go on the line:\n\n");
  824. Xpg("b + will ring the bell when learning is complete.\n");
  825. Xpg("b - will not ring the bell when learning is complete.\n\n");
  826. Xpg("c + will copy i/o to the file, copy.\n");
  827. Xpg("c - will stop writing to the file, copy.\n\n");
  828. Xpg("e + echos the input.\ne - does not echo.\n\n");
  829. Xpg("i c will read pattern values using compressed format.\n");
  830. Xpg("i r will read pattern values as reals.\n\n");
  831. Xpg("o a will write node values as analog compressed.\n");
  832. Xpg("o c will write node values as compressed.\n");
  833. Xpg("o r will write node values as real.\n\n");
  834. Xpg("P <int> sets the page size to <int>; 0 means no paging.\n\n");
  835. Xpg("p c will read patterns in the classification format and ");
  836. Xpg("summarize the results\n    when testing.\n");
  837. Xpg("p C will read patterns in the classification format and ");
  838. Xpg("print every result\n    when testing.\n");
  839. Xpg("p g will accept general patterns and summarize results when ");
  840. Xpg("testing.\n");
  841. Xpg("p G will accept general patterns and print every result when ");
  842. Xpg("testing.\n\n");
  843. Xpg("s + will summarize learning status.\n");
  844. Xpg("s - will not summarize learning status and will");
  845. Xpg(" list each pattern.\n\n");
  846. Xpg("u + will give up-to-date statistics on learning.\n");
  847. Xpg("u - will give statistics one iteration out of date.\n\n");
  848. Xpg("w b will write the weights as binary.\n");
  849. Xpg("w B will write the weights, weight changes and etas as binary.\n");
  850. Xpg("w r will write the weights as real values.\n");
  851. Xpg("w R will write the weights, weight changes and etas as real");
  852. Xpg(" values.\n");
  853. Xbreak;
  854. X
  855. X#ifndef SYMMETRIC
  856. Xcase 'H':
  857. Xpg("H <int> <real> adds a hidden unit to layer <int>\n");
  858. Xpg("Weights are initialized to between -<real> and +<real>.\n");
  859. Xbreak;
  860. X#endif
  861. X
  862. Xcase 'h':
  863. Xpg("h <letter> gives help for command <letter>.\n");
  864. Xbreak;
  865. X
  866. Xcase 'i':
  867. Xpg("i <inputfile> takes commands from the file.\n");
  868. Xpg("i takes commands from the current input file.\n");
  869. Xbreak;
  870. X
  871. Xcase 'k':
  872. Xpg("k <real1> <real2> decreases all the weights in the ");
  873. Xpg("network whose values\nare greater than <real1> by a");
  874. Xpg(" random amount between 0 and <real2>.\nWeights ");
  875. Xpg("less than -<real1> are increased by an amount ");
  876. Xpg("between 0 and <real2>.\nIf <real1> = 0.0, and a ");
  877. Xpg("weight = 0.0 then the weight is changed to\na ");
  878. Xpg("random value between -<real2> and +<real2>.\n");
  879. Xbreak;
  880. X
  881. Xcase 'l':
  882. Xpg("l <int> prints values of nodes on layer <int>.\n");
  883. Xbreak;
  884. X
  885. Xcase 'm':
  886. Xpg("m <int1> <int2> ... <intn> makes a network with\n");
  887. Xpg("<int1> units in the first layer, <int2> units in\n");
  888. Xpg("the second layer, ... , <intn> units in the nth layer.\n");
  889. Xbreak;
  890. X
  891. Xcase 'n':
  892. Xpg("n <int> <in1> <out1> ... <ini> <outi> ... <inN> <outN>");
  893. Xpg(" replaces all\n   training patterns with <int> new ones.\n");
  894. Xpg("n f <trainfile> reads however many patterns there are on");
  895. Xpg(" the file.\n");
  896. Xbreak;
  897. X
  898. Xcase 'O':
  899. Xpg("O <int> will give the output targets for pattern, <int>.\n");
  900. Xbreak;
  901. X
  902. Xcase 'o':
  903. Xpg("o a outputs node values in analog compressed form.");
  904. Xpg("\no c outputs node values in compressed form.\n");
  905. Xpg("o r outputs node values as real.\n");
  906. Xbreak;
  907. X
  908. Xcase 'P':
  909. Xpg("P lists the outputs for all patterns.\n");
  910. Xpg("P <int> gives the output for pattern <int>.\n");
  911. Xpg("P0 gives an up-to-date summary of learning.\n");
  912. Xbreak;
  913. X
  914. Xcase 'p':
  915. Xpg("p <pat> submits the pattern, <pat>, to the input units.\n");
  916. Xbreak;
  917. X
  918. Xcase 'Q':
  919. Xpg("Q <real> sets the value of ? in input patterns to <real>.\n");
  920. Xbreak;
  921. X
  922. Xcase 'q':
  923. Xpg("q followed immediately by a cr ends the program.\n\n");
  924. Xpg("qp is used to set parameters for the quickprop algorithm.\n");
  925. Xpg("One or more of the following commands can go on the line:\n\n");
  926. Xpg("d <real> sets the decay to <real> / 1000.\n");
  927. Xpg("e <real> sets the initial etas to <real>.\n");
  928. Xpg("m <real> sets mu, the accleration parameter to <real>.\n");
  929. Xpg("n <real> sets n, the noise (integer version only) to <real>.\n");
  930. Xpg("s+ adds the slope in to the weight changes (original algorithm).\n");
  931. Xpg("s- does not add the slope in.\n");
  932. Xbreak;
  933. X
  934. Xcase 'R':
  935. Xpg("R restores weights from the current weights file\n");
  936. Xbreak;
  937. X
  938. Xcase 'r':
  939. Xpg("r <int1> <int2> runs <int1> iterations thru the ");
  940. Xpg("patterns.  If <int2> is\npresent, the patterns are ");
  941. Xpg("printed (or summarized) every <int2> iterations.\n\n");
  942. Xpg("rw <filename> reads weights from the file, <filename> and sets ");
  943. Xpg("<filename>\n             to be the current weights file.\n");
  944. Xpg("rw reads weights from the current weights file.\n");
  945. Xbreak;
  946. X
  947. Xcase 'S':
  948. Xpg("S <int> saves the weights on the current weights file every <int>");
  949. Xpg(" iterations.\nS or S 0 saves the weights immediately.\n");
  950. Xbreak;
  951. X
  952. Xcase 's':
  953. Xpg("s <int1> <int2> ... <intn> sets the random number seeds.\n\n");
  954. Xpg("sw <filename> saves weights to the file, <filename> and sets ");
  955. Xpg("<filename>\n              to be the current weights file.\n");
  956. Xpg("sw saves weights to the current weights file.\n");
  957. Xbreak;
  958. X
  959. X#ifdef SYMMETRIC
  960. Xcase 'T':
  961. Xpg("T <real> freezes all threshold weights at <real>.\n");
  962. Xbreak;
  963. X#endif
  964. X
  965. Xcase 't':
  966. Xpg("t <real> sets <real> as the tolerance used in checking for");
  967. Xpg(" complete learning.\n");
  968. Xpg("t f <testfile> tests the patterns on the file.\n");
  969. Xpg("t f tests the patterns on the current test file.\n");
  970. Xpg("t tests the patterns on the current test file.\n");
  971. Xbreak;
  972. X
  973. X#ifndef SYMMETRIC
  974. Xcase 'W':
  975. Xpg("W <real> removes links whose weights are less than ");
  976. Xpg("the absolute value\nof <real>, except links to ");
  977. Xpg("threshold units are not removed.\n");
  978. Xbreak;
  979. X#endif
  980. X
  981. Xcase 'w':
  982. Xpg("w <int1> <int2>  ");
  983. Xpg("prints weights into unit <int2> in layer <int1>.\n");
  984. Xbreak;
  985. X
  986. Xcase 'x':
  987. Xpg("x <int1> <in1> <out1> ... <ini> <outi> ... <inN> <outN>  adds");
  988. Xpg(" the extra\n   <int1> patterns.\n");
  989. Xpg("x f <trainfile> adds the extra patterns found on the file.\n");
  990. Xbreak;
  991. X     }; /* end switch */
  992. Xpg("\n");
  993. X}
  994. END_OF_FILE
  995. if test 25359 -ne `wc -c <'io.c'`; then
  996.     echo shar: \"'io.c'\" unpacked with wrong size!
  997. fi
  998. # end of 'io.c'
  999. fi
  1000. if test -f 'ibp.h' -a "${1}" != "-c" ; then 
  1001.   echo shar: Will not clobber existing file \"'ibp.h'\"
  1002. else
  1003. echo shar: Extracting \"'ibp.h'\" \(3468 characters\)
  1004. sed "s/^X//" >'ibp.h' <<'END_OF_FILE'
  1005. X/* ****************************************************** */
  1006. X/* file ibp.h: contains definitions for programs that use */
  1007. X/*             16-bit integer weights                     */
  1008. X/*                                                        */
  1009. X/* Copyright (c) 1990, 1991, 1992 by Donald R. Tveter     */
  1010. X/*                                                        */
  1011. X/* ****************************************************** */
  1012. X
  1013. X#ifdef DOS16
  1014. X#define INT32 long
  1015. X#define MAXINT 32767
  1016. X#else
  1017. X#define INT32 int
  1018. X#define MAXINT 2147483647
  1019. X#endif
  1020. X
  1021. X#define maxformat 21          /* maximum number of format breaks */
  1022. X#define buffsize 257          /* maximum size of an input line */
  1023. X#define WTTYPE short          /* a 16-bit integer */
  1024. X#define WTSIZE 2              /* shorts are two bytes */
  1025. X#define MAXSHORT 32767        /* largest short */
  1026. X#define MINSHORT -32768       /* smallest short */
  1027. X#define OUTSTRSIZE 257        /* max size of output string */
  1028. X#define HCODE -32768          /* code number for a layer h (2) unit */
  1029. X#define ICODE -32767          /* code number for a layer i (3) unit */
  1030. X#define JCODE -32766          /* code number for a layer j (4) unit */
  1031. X#define KCODE -32765          /* code number for a layer k (5) unit */
  1032. X#define GT 0                  /* a symbol meaning > */
  1033. X#define GE 1                  /* a symbol meaning >= */
  1034. X
  1035. X#ifdef FLOAT
  1036. X#define REAL float
  1037. X#else
  1038. X#define REAL double
  1039. X#endif
  1040. X
  1041. Xtypedef struct seednode
  1042. X   {
  1043. X     unsigned val;            /* a seed value */
  1044. X     struct seednode *next;   /* pointer to next node */
  1045. X   } SEEDNODE;
  1046. Xtypedef struct patlist
  1047. X   {
  1048. X     int bypass;              /* number of times to bypass pattern */
  1049. X     WTTYPE *pats;            /* the list of patterns */
  1050. X     struct patlist *next;    /* pointer to the next pattern */
  1051. X   } PATLIST;
  1052. Xtypedef struct unit
  1053. X   {
  1054. X     short layernumber;       /* layer number of the unit */
  1055. X     short unitnumber;        /* position within layer */
  1056. X     INT32 error;             /* to sum error factors */
  1057. X     WTTYPE oj;               /* state of activation of node */
  1058. X     WTTYPE tj;               /* output target of a node */
  1059. X     struct wtnode *wtlist;   /* the list of weights */
  1060. X     struct unit *next;       /* link to next unit in this layer */
  1061. X   } UNIT;
  1062. X
  1063. Xtypedef struct wtnode
  1064. X   {
  1065. X#ifdef SYMMETRIC
  1066. X     WTTYPE *weight;          /* ptr to weight */
  1067. X     WTTYPE *olddw;           /* ptr to delta wji */
  1068. X     WTTYPE *eta;             /* ptr to eta for the DBD method */
  1069. X     INT32 *total;            /* ptr to total of weight changes */
  1070. X     WTTYPE *slope;           /* previous slope */
  1071. X#else
  1072. X     WTTYPE weight;           /* weight from here to backunit */
  1073. X     WTTYPE olddw;            /* delta wji from previous iteration */
  1074. X     WTTYPE eta;              /* the eta for the DBD method */
  1075. X     INT32 total;             /* total weight changes for batch mode */
  1076. X     WTTYPE slope;            /* previous slope */
  1077. X#endif
  1078. X     struct wtnode *next;     /* link to next node */
  1079. X     UNIT *backunit;          /* ptr to unit the weight comes from */
  1080. X   } WTNODE;
  1081. X
  1082. Xtypedef struct layer
  1083. X   {
  1084. X     int unitcount;           /* number of units in this layer */
  1085. X     struct layer *backlayer; /* pointer to previous layer */
  1086. X     struct layer *next;      /* pointer to next layer */
  1087. X     UNIT *units;             /* start of list of units in this layer */
  1088. X     PATLIST *patstart;       /* to the list of patterns */
  1089. X     PATLIST *currentpat;     /* the current pattern */
  1090. X   } LAYER;
  1091. END_OF_FILE
  1092. if test 3468 -ne `wc -c <'ibp.h'`; then
  1093.     echo shar: \"'ibp.h'\" unpacked with wrong size!
  1094. fi
  1095. # end of 'ibp.h'
  1096. fi
  1097. if test -f 'rbp.h' -a "${1}" != "-c" ; then 
  1098.   echo shar: Will not clobber existing file \"'rbp.h'\"
  1099. else
  1100. echo shar: Extracting \"'rbp.h'\" \(3493 characters\)
  1101. sed "s/^X//" >'rbp.h' <<'END_OF_FILE'
  1102. X/* ***************************************************** */
  1103. X/* file rbp.h:  contains definitions for the rbp program */
  1104. X/*              that uses 64-bit floating point weights  */
  1105. X/*                                                       */
  1106. X/* Copyright (c) 1990, 1991, 1992 by Donald R. Tveter    */
  1107. X/*                                                       */
  1108. X/* *******************************************************/
  1109. X
  1110. X#define maxformat 21
  1111. X#define buffsize 257
  1112. X
  1113. X#ifdef FLOAT
  1114. X#define WTTYPE float
  1115. X#define WTSIZE 4
  1116. X#define REAL float
  1117. X#else
  1118. X#define WTTYPE double
  1119. X#define WTSIZE 8
  1120. X#define REAL double
  1121. X#endif
  1122. X
  1123. X#ifdef DOS16
  1124. X#define INT32 long
  1125. X#define MAXINT 32767
  1126. X#else
  1127. X#define INT32 int
  1128. X#define MAXINT 2147483647
  1129. X#endif
  1130. X
  1131. X#define HCODE -32768          /* code number for a layer h (2) unit */
  1132. X#define ICODE -32767          /* code number for a layer i (3) unit */
  1133. X#define JCODE -32766          /* code number for a layer j (4) unit */
  1134. X#define KCODE -32765          /* code number for a layer k (5) unit */
  1135. X#define GT 0                  /* a symbol meaning > */
  1136. X#define GE 1                  /* a symbol meaning >= */
  1137. X#define OUTSTRSIZE 257        /* max length of output string */
  1138. X#define scale(x) x            /* scale not used in real version */
  1139. X#define unscale(x) x          /* unscale not used in real version */
  1140. X#define unscaleint(x) x       /* unscaleint not used in real version */
  1141. X
  1142. Xtypedef struct seednode
  1143. X   {
  1144. X     unsigned val;            /* a seed value */
  1145. X     struct seednode *next;   /* pointer to next node */
  1146. X   } SEEDNODE;
  1147. Xtypedef struct patlist
  1148. X   {
  1149. X     int bypass;              /* number of times to bypass pattern */
  1150. X     WTTYPE *pats;            /* the list of patterns */
  1151. X     struct patlist *next;    /* pointer to the next pattern */
  1152. X   } PATLIST;
  1153. Xtypedef struct unit
  1154. X   {
  1155. X     short layernumber;       /* layer number of the unit */
  1156. X     short unitnumber;        /* position within layer */
  1157. X     REAL error;              /* to sum error factors */
  1158. X     WTTYPE oj;               /* state of activation of node */
  1159. X     WTTYPE tj;               /* output target for the node */
  1160. X     struct unit *wtlist;     /* to list of weights to prev layer */
  1161. X     struct unit *next;       /* link to next unit in this layer */
  1162. X   } UNIT;
  1163. X
  1164. Xtypedef struct wtnode
  1165. X   {
  1166. X#ifdef SYMMETRIC
  1167. X     WTTYPE *weight;          /* weight from here to backunit */
  1168. X     WTTYPE *olddw;           /* delta wji from previous iteration */
  1169. X     WTTYPE *total;           /* total of changes for batch updates */
  1170. X     WTTYPE *eta;             /* the eta of the DBD method */
  1171. X     WTTYPE *slope;           /* previous slope */
  1172. X#else
  1173. X     WTTYPE weight;           /* weight from here to backunit */
  1174. X     WTTYPE olddw;            /* delta wji from previous iterataion */
  1175. X     WTTYPE total;            /* total of changes for batch updates */
  1176. X     WTTYPE eta;              /* the eta of the DBD method */
  1177. X     WTTYPE slope;            /* previous slope */
  1178. X#endif
  1179. X     struct wtnode *next;     /* link to next node */
  1180. X     UNIT *backunit;          /* ptr to unit the weight comes from */
  1181. X   } WTNODE;
  1182. X
  1183. Xtypedef struct layer
  1184. X   {
  1185. X     int unitcount;           /* number of units in this layer */
  1186. X     struct layer *backlayer; /* pointer to previous layer */
  1187. X     struct layer *next;      /* pointer to next layer */
  1188. X     UNIT *units;             /* start of list of units in this layer */
  1189. X     PATLIST *patstart;       /* to the list of patterns */
  1190. X     PATLIST *currentpat;     /* the current pattern */
  1191. X   } LAYER;
  1192. END_OF_FILE
  1193. if test 3493 -ne `wc -c <'rbp.h'`; then
  1194.     echo shar: \"'rbp.h'\" unpacked with wrong size!
  1195. fi
  1196. # end of 'rbp.h'
  1197. fi
  1198. if test -f 'makefile' -a "${1}" != "-c" ; then 
  1199.   echo shar: Will not clobber existing file \"'makefile'\"
  1200. else
  1201. echo shar: Extracting \"'makefile'\" \(2257 characters\)
  1202. sed "s/^X//" >'makefile' <<'END_OF_FILE'
  1203. X#
  1204. X# This makefile can be used to make all 4 programs but note that
  1205. X# it is designed to make compiling the integer version bp easy
  1206. X# by keeping its object files around.  The other 3 programs erase
  1207. X# their object files.
  1208. X#
  1209. X# Below, where I say 32-bit floating point or 64-bit floating point,
  1210. X# note that the program uses some floating point instructions even the
  1211. X# integer versions, bp and sbp.  In standard UNIX C all floating point
  1212. X# arithmetic is done as double so using double values actually is faster
  1213. X# than using float values (because all the covnersions take time).
  1214. X# To use float rather than double define FLOAT like so:  -DFLOAT
  1215. X#
  1216. X# To get the compiler to use 32-bit DOS settings include: -DDOS32
  1217. X# To get the compiler to use 16-bit DOS settings include: -DDOS16
  1218. X#
  1219. X# Below are the settings I've been using for Zortech 3.0.
  1220. X# The -f flag in the ZORTECH CFLAGS forces hardware floating point
  1221. X# instructions to be generated.  The -o is for optimize, -m is used
  1222. X# to give the memory model.  NOTE that in the following makefile I don't
  1223. X# use the Zortech optimization flag -o in the CFLAGS, instead it is used
  1224. X# in the definitions for bp.obj, misc.obj and int.obj because for
  1225. X# some reason the compiler bombs when it optimizes io.obj.  As its
  1226. X# set up, sbp, srbp and rbp will not be optimized.
  1227. X#
  1228. X# use the following line for DOS/ZORTECH (486)
  1229. X#CFLAGS= -mx -4 -f -DFLOAT -DDOS32
  1230. X# use the following line for DOS/ZORTECH (386)
  1231. X#CFLAGS= -mx -3 -DFLOAT -DDOS32
  1232. X# use the following line for DOS/ZORTECH (286)
  1233. X#CFLAGS= -mz -2 -f -DFLOAT -DDOS16
  1234. X# use the following line for DOS/ZORTECH (8088) large memory model
  1235. XCFLAGS= -ml -f -DFLOAT -DDOS16
  1236. X
  1237. Xbp: bp.obj io.obj misc.obj int.obj makefile ibp.h
  1238. X    ztc $(CFLAGS) bp.obj io.obj misc.obj int.obj -obp.exe
  1239. X
  1240. Xsbp:
  1241. X    ztc -DINTEGER -DSYMMETRIC int.c bp.c io.c misc.c $(CFLAGS) -osbp.exe
  1242. X    erase *.obj
  1243. X
  1244. Xrbp:
  1245. X    ztc real.c bp.c io.c misc.c $(CFLAGS) -orbp.exe
  1246. X    erase *.obj
  1247. X
  1248. Xsrbp:
  1249. X    ztc -DSYMMETRIC real.c bp.c io.c misc.c $(CFLAGS) -osrbp.exe
  1250. X    erase *.obj
  1251. X
  1252. Xbp.obj: bp.c ibp.h makefile
  1253. X    ztc -DINTEGER $(CFLAGS) bp.c -c -o
  1254. X
  1255. Xio.obj: io.c ibp.h makefile
  1256. X    ztc -DINTEGER $(CFLAGS) io.c -c
  1257. X
  1258. Xmisc.obj: misc.c ibp.h makefile
  1259. X    ztc -DINTEGER $(CFLAGS) misc.c -c -o
  1260. X
  1261. Xint.obj: int.c ibp.h makefile
  1262. X    ztc -DINTEGER -DSMART $(CFLAGS) int.c -c -o
  1263. END_OF_FILE
  1264. if test 2257 -ne `wc -c <'makefile'`; then
  1265.     echo shar: \"'makefile'\" unpacked with wrong size!
  1266. fi
  1267. # end of 'makefile'
  1268. fi
  1269. if test -f 'makereal' -a "${1}" != "-c" ; then 
  1270.   echo shar: Will not clobber existing file \"'makereal'\"
  1271. else
  1272. echo shar: Extracting \"'makereal'\" \(1677 characters\)
  1273. sed "s/^X//" >'makereal' <<'END_OF_FILE'
  1274. X#
  1275. X# This makefile is designed to make only the rbp program AND TO KEEP
  1276. X# all the .obj files, so you can apply changes to one file without
  1277. X# recompiling all the others.
  1278. X#
  1279. X# Below, where I say 32-bit floating point or 64-bit floating point,
  1280. X# note that all the programs use some floating point instructions even
  1281. X# the integer versions, bp and sbp.  In standard UNIX C all floating
  1282. X# point arithmetic is done as double so using double values actually is
  1283. X# faster than using float values (because all the covnersions take
  1284. X# time).  To use float rather than double define FLOAT like so:  -DFLOAT
  1285. X#
  1286. X# To get the compiler to use 32-bit DOS settings include: -DDOS32
  1287. X# To get the compiler to use 16-bit DOS settings include: -DDOS16
  1288. X#
  1289. X# Below are the settings I've been using for Zortech C 3.0.
  1290. X# The -f flag in the ZORTECH CFLAGS forces hardware floating point
  1291. X# instructions to be generated.  The -o is for optimize, -m is used
  1292. X# to give the memory model, -4 for a 486, -3 for a 386, -2 for a 286.
  1293. X#
  1294. X# use the following line for DOS/ZORTECH (486)
  1295. XCFLAGS= -mx -4 -f -o -DFLOAT -DDOS32
  1296. X# use the following line for DOS/ZORTECH (386)
  1297. X#CFLAGS= -mx -3 -o -DFLOAT -DDOS32
  1298. X# use the following line for DOS/ZORTECH (286)
  1299. X#CFLAGS= -mz -2 -f -o -DFLOAT -DDOS16
  1300. X# use the following line for DOS/ZORTECH (8088) large memory model
  1301. X#CFLAGS= -ml -f -o -DFLOAT -DDOS16
  1302. X
  1303. Xrbp: bp.obj io.obj misc.obj real.obj makereal rbp.h
  1304. X    ztc $(CFLAGS) bp.obj io.obj misc.obj real.obj -orbp.exe
  1305. X
  1306. Xbp.obj: bp.c rbp.h makereal
  1307. X    ztc $(CFLAGS) bp.c -c
  1308. X
  1309. Xio.obj: io.c rbp.h makereal
  1310. X    ztc $(CFLAGS) io.c -c
  1311. X
  1312. Xmisc.obj: misc.c rbp.h makereal
  1313. X    ztc $(CFLAGS) misc.c -c
  1314. X
  1315. Xreal.obj: real.c rbp.h makereal
  1316. X    ztc $(CFLAGS) real.c -c
  1317. END_OF_FILE
  1318. if test 1677 -ne `wc -c <'makereal'`; then
  1319.     echo shar: \"'makereal'\" unpacked with wrong size!
  1320. fi
  1321. # end of 'makereal'
  1322. fi
  1323. if test -f 'makefile.unx' -a "${1}" != "-c" ; then 
  1324.   echo shar: Will not clobber existing file \"'makefile.unx'\"
  1325. else
  1326. echo shar: Extracting \"'makefile.unx'\" \(774 characters\)
  1327. sed "s/^X//" >'makefile.unx' <<'END_OF_FILE'
  1328. X# for 32-bit floating point use the following line:
  1329. X#CFLAGS= -s -O -DFLOAT -DUNIX
  1330. X# for 64-bit floating point use the following line:
  1331. XCFLAGS= -s -O -DUNIX
  1332. X
  1333. Xbp: bp.o io.o misc.o int.o makefile ibp.h
  1334. X    cc $(CFLAGS) bp.o io.o misc.o int.o -o bp
  1335. X
  1336. Xsbp:
  1337. X    cc -DINTEGER -DSYMMETRIC int.c bp.c io.c misc.c $(CFLAGS) -o sbp
  1338. X    rm bp.o io.o int.o misc.o
  1339. X
  1340. Xrbp:
  1341. X    cc real.c bp.c io.c misc.c $(CFLAGS) -lm -o rbp
  1342. X    rm bp.o io.o real.o misc.o
  1343. X
  1344. Xsrbp:
  1345. X    ztc -DSYMMETRIC real.c bp.c io.c misc.c $(CFLAGS) -lm -o srbp
  1346. X    rm bp.o io.o real.o misc.o
  1347. X
  1348. Xbp.o: bp.c ibp.h makefile
  1349. X    cc -DINTEGER $(CFLAGS) bp.c -c
  1350. X
  1351. Xio.o: io.c ibp.h makefile
  1352. X    cc -DINTEGER $(CFLAGS) io.c -c
  1353. X
  1354. Xmisc.o: misc.c ibp.h makefile
  1355. X    cc -DINTEGER $(CFLAGS) misc.c -c
  1356. X
  1357. Xint.o: int.c ibp.h makefile
  1358. X    cc -DINTEGER -DSMART $(CFLAGS) int.c -c
  1359. END_OF_FILE
  1360. if test 774 -ne `wc -c <'makefile.unx'`; then
  1361.     echo shar: \"'makefile.unx'\" unpacked with wrong size!
  1362. fi
  1363. # end of 'makefile.unx'
  1364. fi
  1365. echo shar: End of archive 3 \(of 4\).
  1366. cp /dev/null ark3isdone
  1367. MISSING=""
  1368. for I in 1 2 3 4 ; do
  1369.     if test ! -f ark${I}isdone ; then
  1370.     MISSING="${MISSING} ${I}"
  1371.     fi
  1372. done
  1373. if test "${MISSING}" = "" ; then
  1374.     echo You have unpacked all 4 archives.
  1375.     rm -f ark[1-9]isdone
  1376. else
  1377.     echo You still need to unpack the following archives:
  1378.     echo "        " ${MISSING}
  1379. fi
  1380. ##  End of shell archive.
  1381. exit 0
  1382.  
  1383. exit 0 # Just in case...
  1384.