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