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