home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / tools / sources / snnsbat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  42.0 KB  |  1,618 lines
  1. /*****************************************************************************
  2.   FILE           : snnsbat.c
  3.   SHORTNAME      : snnsbat
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : SNNS Batchlearning Program
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Guenter Mamier
  10.   DATE           : 24.07.92
  11.  
  12.   CHANGED BY     : Guenter Mamier
  13.   IDENTIFICATION : @(#)snnsbat.c    1.21 4/20/94
  14.   SCCS VERSION   : 1.21
  15.   LAST CHANGE    : 4/20/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <signal.h>
  24. #include <ctype.h>
  25. #include <limits.h>
  26. #include <time.h>
  27. #include <string.h>
  28. #include <fcntl.h>
  29. #include <sys/param.h>
  30. #include <sys/types.h>
  31. #include <sys/times.h>
  32. #include <sys/utsname.h>
  33.  
  34. #include "glob_typ.h"   /* SNNS-Kernel constants and data type definitions  */
  35. #include "kr_ui.h"      /* SNNS-Kernel User-Interface Function Prototypes   */
  36. #include "kr_typ.h"
  37. #include "kr_newpattern.h"
  38.  
  39. #include "snnsbat.h"
  40.  
  41.  
  42.  
  43. /*****************************************************************************
  44.   FUNCTION : skipComments
  45.  
  46.   PURPOSE  : to skip comments
  47.   NOTES    :
  48.  
  49.   AUTHOR   : Niels Mache
  50.   RETURNS  : FALSE, if EOF is detected
  51.   UPDATE   : 
  52. ******************************************************************************/
  53. static    bool skipComments(register FILE *stream)
  54. {
  55.     register int   c;
  56.  
  57.     while(TRUE){
  58.     do{ c = getc(stream);}
  59.     while(isspace(c));
  60.  
  61.     if(c != '#')break;
  62.  
  63.     do{ c = getc(stream);}while(c != EOF && c != '\n');
  64.     }
  65.  
  66.     if(c == EOF)  
  67.     return(FALSE);
  68.  
  69.     ungetc(c,stream);
  70.     return( TRUE );
  71. }
  72.  
  73.  
  74.  
  75. /*****************************************************************************
  76.   FUNCTION : skipRestOfLine
  77.  
  78.   PURPOSE  : to skip the rest of a line
  79.   NOTES    :
  80.  
  81.   AUTHOR   : Michael Vogt
  82.   RETURNS  : 
  83.   UPDATE   : 
  84. ******************************************************************************/
  85. static void skipRestOfLine(register FILE  *stream)
  86. {
  87.     register int   c;
  88.  
  89.     do
  90.     {
  91.     c = getc(stream);
  92.     } while (c != EOF && c != '\n');
  93. }
  94.  
  95.  
  96.  
  97. /*****************************************************************************
  98.   FUNCTION : errChk
  99.  
  100.   PURPOSE  : Check for errors
  101.   NOTES    :
  102.  
  103.   AUTHOR   : Niels Mache
  104.   RETURNS  : Error code
  105.   UPDATE   : 
  106. ******************************************************************************/
  107. static void  errChk(int errNo)
  108. {
  109.     if(errNo != KRERR_NO_ERROR){
  110.     fprintf(stderr, "Batchlearning: %s\n", krui_error(errNo));
  111.     if(file_out != NULL)
  112.         fprintf(file_out,"Batchlearning: %s\n",krui_error(errNo));
  113.     exit(1);
  114.     }
  115. }
  116.  
  117.  
  118.  
  119. /*****************************************************************************
  120.   FUNCTION : writeLearnFuncValues
  121.  
  122.   PURPOSE  : write the learning function values to the log file
  123.   NOTES    :
  124.  
  125.   AUTHOR   : Niels Mache
  126.   RETURNS  : 
  127.   UPDATE   : 
  128. ******************************************************************************/
  129. static void  writeLearnFuncValues()
  130. {
  131.     int  j;
  132. /*
  133.     fprintf(file_out,"\nCycle: %d\nLearning function value(s): ",cycle);
  134.     for(j=0; j<no_of_return_values; j++)
  135.     fprintf(file_out,"[%d]: %g  ",j+1,return_values[j]);
  136.     fprintf(file_out,"\n");
  137. */
  138.     fprintf(file_out,"  %5d:    %10.5f", cycle + 1,return_values[0]);
  139.     fprintf(file_out,"     %10.5f",(return_values[0]/krui_getNoOfPatterns()));
  140.     if (krui_getNoOfOutputUnits() > 0)
  141.     fprintf(file_out,"        %10.5f\n", 
  142.         (return_values[0]/krui_getNoOfOutputUnits()));
  143.     else
  144.     fprintf(file_out,"\n");
  145.  
  146. }
  147.  
  148.  
  149.  
  150. /*****************************************************************************
  151.   FUNCTION : writeInfo
  152.  
  153.   PURPOSE  : write system information
  154.   NOTES    :
  155.  
  156.   AUTHOR   : Niels Mache
  157.   RETURNS  : 
  158.   UPDATE   : 
  159. ******************************************************************************/
  160. static void  writeInfo(FILE *stream)
  161. {
  162.     time_t       clock;
  163.     struct utsname name;
  164.  
  165.     if(stream != NULL){
  166.     clock = 1;
  167.     (void) time(&clock);
  168.  
  169.     fprintf(stream, "\n%s Batchlearning terminated at %s",
  170.         krui_getVersion(),ctime(&clock));
  171.     if(uname(&name) == 0)
  172.         fprintf(stream, "System: %s  Node: %s  Machine: %s\n",
  173.             name.sysname, name.nodename, name.machine );
  174.     }
  175. }
  176.  
  177.  
  178.  
  179. /*****************************************************************************
  180.   FUNCTION : writeStatistics
  181.  
  182.   PURPOSE  : write Statistics
  183.   NOTES    :
  184.  
  185.   AUTHOR   : Niels Mache
  186.   RETURNS  : 
  187.   UPDATE   : 
  188. ******************************************************************************/
  189. static void  writeStatistics(bool status)
  190. {
  191.     time_t  clock;
  192.     float cpu_time;
  193.  
  194.  
  195.     if(file_out != NULL){
  196.     clock = 1;
  197.     (void)time(&clock);
  198.     (void)times(&tp);
  199.     cpu_time = (float)tp.tms_utime / (float)HZ_value;
  200.  
  201.     writeInfo(file_out);
  202.     fprintf(file_out, 
  203.         "********************************************************\n");
  204.     fprintf(file_out,"\n----   STATISTICS  ----\n");
  205.     fprintf(file_out,"No. of learned cycles: %d\n",cycle);
  206.     if(status)  
  207.         writeLearnFuncValues();
  208.     fprintf(file_out,"No. of units updated : %d\n", 
  209.         no_of_units * cycle * no_of_patterns);
  210.     fprintf(file_out,"No. of sites updated : %d\n", 
  211.         no_of_sites * cycle * no_of_patterns);
  212.     fprintf(file_out,"No. of links updated : %d\n", 
  213.         no_of_links * cycle * no_of_patterns);
  214.     fprintf(file_out,"CPU Time used: %.2f seconds\n",cpu_time);
  215.     fprintf(file_out,"User time: %d seconds\n",clock-starttime);
  216.     fprintf(file_out,"No. of connection updates per second (CUPS): %e\n\n",
  217.         ((double)no_of_links * (double)cycle * 
  218.          (double)no_of_patterns) / ((double)cpu_time));
  219.  
  220.     }
  221. }
  222.  
  223.  
  224.  
  225.  
  226. /*****************************************************************************
  227.   FUNCTION : writeCaughtMsg
  228.  
  229.   PURPOSE  : log the number of a caught signal
  230.   NOTES    :
  231.  
  232.   RETURNS  : 
  233.   UPDATE   : 
  234. ******************************************************************************/
  235. static void  writeCaughtMsg(int msg)
  236. {
  237.   fprintf( stdout, "\nSignal %d caught, %s Batchlearning terminated.\n",
  238.       msg, krui_getVersion() );
  239.   writeInfo( stdout );
  240.  
  241.   if(file_out != NULL){
  242.     fprintf(file_out, 
  243.         "\n#####  Signal %d caught, %s Batchlearning terminated.\n",
  244.         msg, krui_getVersion() );
  245.     writeInfo( file_out );
  246.   }
  247. }
  248.  
  249.  
  250.  
  251. /*****************************************************************************
  252.   FUNCTION : emergency_exit
  253.  
  254.   PURPOSE  : exit after signal
  255.   NOTES    :
  256.  
  257.   RETURNS  : 
  258.   UPDATE   : 
  259. ******************************************************************************/
  260. static void  emergency_exit(int msg)
  261. {
  262.     writeCaughtMsg(msg);
  263.  
  264.     fprintf(stdout,"\nFatal Error in SNNS-Kernel. Networkfile is lost.\n");
  265.  
  266.     if(file_out != NULL) {
  267.     fprintf( stdout, 
  268.         "\n#####  Fatal Error in SNNS-Kernel. Networkfile is lost.\n");
  269.     writeStatistics(ABNORMAL);
  270.     fprintf(stdout, "Logfile '%s' written.\n",log_file);
  271.     fclose(file_out);
  272.     }
  273.  
  274.     exit(-3);
  275. }
  276.  
  277.  
  278.  
  279.  
  280. /*****************************************************************************
  281.   FUNCTION : exit_batchlearn
  282.  
  283.   PURPOSE  : handle signals
  284.   RETURNS  : 
  285.   NOTES    :
  286.  
  287.   UPDATE   : 
  288. ******************************************************************************/
  289. static void  exit_batchlearn(int msg)
  290. {
  291.     char *tmp_file;
  292.  
  293.  
  294.     writeCaughtMsg(msg);
  295.  
  296.     if(krui_getNoOfUnits() > 0){ /*  save network  */
  297.     if(tmp_switch & 1)
  298.         tmp_file = tmp_file1;
  299.     else
  300.         tmp_file = tmp_file2;
  301.  
  302.     (void) krui_saveNet(tmp_file,netname);
  303.     fprintf( stdout, "Networkfile '%s' saved.\n",tmp_file);
  304.     if(file_out != NULL)
  305.         fprintf(file_out,"Networkfile '%s' saved.\n",tmp_file);
  306.     }
  307.  
  308.     if(file_out != NULL){
  309.     writeStatistics(ABNORMAL);
  310.     fprintf(stdout,"Logfile '%s' written.\n",log_file);
  311.     fclose(file_out);
  312.     }
  313.  
  314.     exit(-2);
  315. }
  316.  
  317.  
  318.  
  319. /*****************************************************************************
  320.   FUNCTION : catchSignals
  321.  
  322.   PURPOSE  : catch these signals
  323.   RETURNS  : 
  324.   NOTES    :
  325.  
  326.   UPDATE   : 
  327. ******************************************************************************/
  328. static void  catchSignals()
  329. {
  330.   signal( SIGHUP,  exit_batchlearn );  
  331.   signal( SIGINT,  exit_batchlearn );
  332.   signal( SIGQUIT, exit_batchlearn );
  333.   signal( SIGALRM, exit_batchlearn );
  334.   signal( SIGTERM, exit_batchlearn );
  335.  
  336. #ifdef SIGPWR
  337.   signal( SIGPWR,  exit_batchlearn );
  338. #endif
  339.  
  340.   signal( SIGILL,  emergency_exit );
  341.   signal( SIGTRAP, emergency_exit );
  342.   signal( SIGIOT,  emergency_exit );
  343. #ifdef SIGEMT
  344.   signal( SIGEMT,  emergency_exit );
  345. #endif
  346.   signal( SIGFPE,  emergency_exit );
  347. #ifdef SIGBUS
  348.   signal( SIGBUS,  emergency_exit );
  349. #endif
  350.   signal( SIGSEGV, emergency_exit );
  351. }
  352.  
  353.  
  354.  
  355. /*****************************************************************************
  356.   FUNCTION : IsOld
  357.  
  358.   PURPOSE  : test an input string against the string <OLD>
  359.   RETURNS  : 1 if string matches
  360.   NOTES    :
  361.  
  362.   UPDATE   : 
  363. ******************************************************************************/
  364. static int IsOld(char *stream)
  365. {
  366.     char temp[80];
  367.     int  i=0,j=0;
  368.  
  369.     strcpy(temp,"<OLD>");
  370.     while(stream[i] == ' ' || stream[i] == '\t')i++; 
  371.     for(j=0; j<5; j++)temp[j] = toupper(stream[i+j]);
  372.  
  373.     if(strcmp(temp,"<OLD>") == 0)return(1);
  374.  
  375.     return(0);
  376.  
  377. }
  378.  
  379.  
  380. /*****************************************************************************
  381.   FUNCTION : getYesNoSwitch
  382.  
  383.   PURPOSE  : read a YES/NO switch
  384.   RETURNS  : 
  385.   NOTES    :
  386.  
  387.   UPDATE   : 
  388. ******************************************************************************/
  389. static int  getYesNoSwitch(FILE  *file_in)
  390. {
  391.     int  i, ret;
  392.     char do_shuffleing[80];
  393.  
  394.  
  395.     skipComments(file_in);
  396.     ret = fscanf(file_in,"%s",do_shuffleing);
  397.     if(ret != 1)return(-2);
  398.  
  399.     if(IsOld(do_shuffleing))
  400.     return(-1);
  401.  
  402.     for(i=0; i<(size_t)strlen(do_shuffleing); i++)
  403.     do_shuffleing[i] = toupper(do_shuffleing[i]);
  404.  
  405.     if(strcmp(do_shuffleing,"YES") == 0)return(1);
  406.     if(strcmp(do_shuffleing,"NO") != 0)return(-2);
  407.  
  408.     return(0);
  409. }
  410.  
  411.  
  412.  
  413. /*****************************************************************************
  414.   FUNCTION : do_initial_log 
  415.  
  416.   PURPOSE  : log the initial settings
  417.   RETURNS  : 
  418.   NOTES    :
  419.  
  420.   UPDATE   : 
  421. ******************************************************************************/
  422. static void do_initial_log()
  423. {
  424.  
  425.     int i, ret;
  426.  
  427.  
  428.     /* log network info */
  429.  
  430.     krui_getNetInfo(&no_of_sites,&no_of_links,&ret,&ret);
  431.     no_of_units = krui_getNoOfUnits();
  432.     fprintf( file_out,"Network name             : %s\n", netname );
  433.     fprintf( file_out,"No. of units             : %d\n", no_of_units );
  434.     fprintf( file_out,"No. of sites             : %d\n", no_of_sites );
  435.     fprintf( file_out,"No. of links             : %d\n", no_of_links );
  436.     fprintf( file_out,"\nLearning Function        : %s\n",krui_getLearnFunc());
  437.     for(i=0; i<no_of_learn_param; i++)
  438.     fprintf(file_out,"Learning Parameter #%d    : %f\n",i+1,
  439.         learn_param[i]);
  440.     fprintf(file_out,"\n");
  441.  
  442.  
  443.     /* log variable Dimensions */
  444.  
  445.     if(NoOfVarDimFlag != 0){
  446.     fprintf(file_out,"\nUsing variable sub-patterns\n");
  447.     fprintf(file_out,"Input Dimensions         : ");
  448.     for(i=0; i<no_of_var_dim[0]; i++)
  449.         fprintf(file_out,"%d ",SubPatternISize_param[i]);
  450.     fprintf(file_out,"\nOutput Dimensions        : ");
  451.     for(i=0; i<no_of_var_dim[1]; i++)
  452.         fprintf(file_out,"%d ",SubPatternOSize_param[i]);
  453.     fprintf(file_out,"\nInput Step Size          : ");
  454.     for(i=0; i<no_of_var_dim[0]; i++)
  455.         fprintf(file_out,"%d ",SubPatternIStep_param[i]);
  456.     fprintf(file_out,"\nOutput Step Size         : ");
  457.     for(i=0; i<no_of_var_dim[1]; i++)
  458.         fprintf(file_out,"%d ",SubPatternOStep_param[i]);
  459.     fprintf(file_out,"\n");
  460.     }
  461.  
  462.  
  463.     /* log test pattern file */
  464.  
  465.     if(test_pat_file[0] != '\0')
  466.     fprintf(file_out,"\nTest pattern file : '%s'\n",test_pat_file);
  467.  
  468.  
  469.     /* log initialization settings */
  470.  
  471.     if(init_func[0] == '\0'){
  472.     fprintf( file_out, "\nNo Initialization \n");
  473.     }else{
  474.     fprintf( file_out,"\nInit Function: %s\n",init_func);
  475.     for(i=0; i<no_of_init_param; i++)
  476.         fprintf(file_out,"Init Parameter #%d       : %f\n",i+1,
  477.             init_param[i]);
  478.     }
  479.     fprintf(file_out,"\n");
  480.  
  481.  
  482.     /* log result file settings */
  483.  
  484.     if(res_file[0] == '\0'){
  485.     fprintf(file_out,"No Result File \n");
  486.     }else{
  487.     fprintf(file_out,"\nResult File              : '%s'\n",res_file);
  488.     fprintf(file_out,"Result File Start Pattern: %d\n",start_pattern);
  489.     fprintf(file_out,"Result File End Pattern  : %d\n",end_pattern);
  490.     if(input_included)
  491.         fprintf(file_out,"Result File Input Pattern included\n");
  492.     if(output_included)
  493.         fprintf(file_out,"Result File Output Pattern included\n");
  494.     fprintf(file_out, "\n" );
  495.     }
  496.     fprintf(file_out, 
  497.         "\n********************************************************\n");
  498.  
  499.  
  500. }
  501.  
  502.  
  503.  
  504.  
  505. /*****************************************************************************
  506.   FUNCTION : configError
  507.  
  508.   PURPOSE  : report errors in configuration file
  509.   RETURNS  : 
  510.   NOTES    :
  511.  
  512.   UPDATE   : 
  513. ******************************************************************************/
  514. static void configError(int err_code, char* err_string)
  515. {
  516.     switch(err_code){
  517.     case 1:
  518.     fprintf(stderr,"\n\nERROR !!\n");
  519.     fprintf(stderr,"Configuration file must first disclose type\n" );
  520.     SyntaxError += 1;
  521.     exit(1);
  522.     case 2:
  523.     fprintf(stderr,"\n\nERROR !!\n");
  524.     fprintf(stderr,"This program handles only filetypes%s and%s not %s\n",
  525.         " SNNSBATCH_1"," SNNSBATCH_2",err_string);
  526.     SyntaxError += 1;
  527.     exit(1);
  528.     case 3:
  529.     fprintf(stderr,"\n\nERROR !!\n");
  530.     fprintf(stderr,"Wrong number of learn params given !!\n");
  531.     SyntaxError += 1;
  532.     break;
  533.     case 4:
  534.     fprintf(stderr,"\n\nERROR !!\n");
  535.     fprintf(stderr,"Wrong number of %s params given !!\n",err_string);
  536.     SyntaxError += 1;
  537.     break;
  538.     case 5:
  539.     fprintf(stderr,"\n\nWARNING !!\n");
  540.     fprintf(stderr,"Found unknown key in configuration file!!\n");
  541.     fprintf(stderr,"\nIgnoring unknown key '%s'!!\n",    err_string);
  542.     SyntaxWarning += 1;
  543.     break;
  544.     case 6:
  545.     fprintf(stderr,"\n\nERROR !!\n");
  546.     fprintf(stderr,"No pattern file for training specified in loop %d!!\n",
  547.         exec_loop+1);
  548.     SyntaxError += 1;
  549.     break;
  550.     case 7:
  551.     fprintf(stderr,"\n\nERROR !!\n");
  552.     fprintf(stderr,"Invalid argument for key %s\n",err_string);
  553.     SyntaxError += 1;
  554.     break;
  555.     case 8:
  556.     fprintf(stderr,"\n\nERROR !!\n");
  557.     fprintf(stderr,"%s Value <OLD> not allowed in first loop\n",
  558.         err_string);
  559.     SyntaxError += 1;
  560.     break;
  561.     case 9:
  562.     fprintf(stderr,"\n\nWARNING !!\n");
  563.     fprintf(stderr,"Value <OLD> for key LearnPatternFile: in loop %d ",
  564.         exec_loop+1);
  565.     fprintf(stderr,"\nuses loaded TEST pattern file of previous loop\n\n");
  566.     SyntaxWarning += 1;
  567.     break;
  568.     case 10:
  569.     fprintf(stderr,"\n\nWARNING !!\n");
  570.     fprintf(stderr,"Result file parameters specified without file name");
  571.     fprintf(stderr," in loop %d!!\n",exec_loop);
  572.     fprintf(stderr,"Result file will not be generated !!\n\n");
  573.     SyntaxWarning += 1;
  574.     break;
  575.     case 11:
  576.     fprintf(stderr,"\n\nWARNING !!\n");
  577.     fprintf(stderr,"Init function parameters specified without function ");
  578.     fprintf(stderr,"name in loop %d!!\n",exec_loop);
  579.     fprintf(stderr,"Net will not be initialized in loop %d!!\n",
  580.         exec_loop);
  581.     SyntaxWarning += 1;
  582.     break;
  583.     case 12:
  584.     fprintf(stderr,"\n\nWARNING !!\n");
  585.     if(strcmp(err_string,"LEARN")==0){
  586.         fprintf(stderr,"Not more than %d Learning parameters allowed.\n",
  587.             NO_OF_LEARN_PARAMS);
  588.         fprintf(stderr,"Only %d  are used !!\n",NO_OF_LEARN_PARAMS);
  589.     }else{
  590.         fprintf(stderr,"Not more than %d Init parameters allowed.\n",
  591.             NO_OF_INIT_PARAMS);
  592.         fprintf(stderr,"Only %d are used !!\n",NO_OF_INIT_PARAMS);
  593.     }
  594.     SyntaxWarning += 1;
  595.     break;
  596.     case 13:
  597.     fprintf(stderr,"\n\nERROR !!\n");
  598.     fprintf(stderr,"No more memory available\n");
  599.     exit(1);
  600.     case 14:
  601.     fprintf(stderr,"\n\nERROR !!\n");
  602.     fprintf(stderr,"Loop %d: New network can not use old Patterns\n",
  603.         exec_loop);
  604.     SyntaxError += 1;
  605.     break;
  606.     case 15:
  607.     fprintf(stderr,"\n\nERROR !!\n");
  608.     fprintf(stderr,"Loop %d: Subpattern: No Size specified\n",exec_loop);
  609.     SyntaxError += 1;
  610.     break;
  611.     case 16:
  612.     fprintf(stderr,"\n\nERROR !!\n");
  613.     fprintf(stderr,"Loop %d: Subpattern: No Step specified\n",exec_loop);
  614.     SyntaxError += 1;
  615.     break;
  616.     case 17:
  617.     fprintf(stderr,"\n\nERROR !!\n");
  618.     fprintf(stderr,"Subpattern: Need two %s Dimension values\n",
  619.         err_string);
  620.     SyntaxError += 1;
  621.     break;
  622.     case 18:
  623.     fprintf(stderr,"\n\nERROR !!\n");
  624.     fprintf(stderr,"No number of variable pattern sizes given for ");
  625.     fprintf(stderr,"subpatterns in loop %d\n",exec_loop);
  626.     SyntaxError += 1;
  627.     break;
  628.     default:
  629.     fprintf(stderr,"\n\nDon't known what to make of unknown parsing ");
  630.     fprintf(stderr,"error %d\nAborting scan\n",err_code);
  631.     exit(1);
  632.     }
  633. }
  634.  
  635.  
  636.  
  637.  
  638.  
  639. /*****************************************************************************
  640.   FUNCTION : scanParameter
  641.  
  642.   PURPOSE  : Read in a number of values in one line
  643.   RETURNS  : 
  644.   NOTES    :
  645.  
  646.   UPDATE   : 
  647. ******************************************************************************/
  648. static bool scanParameter(void *field, char  *string, int number, bool isInt)
  649. {
  650.     register int i, ret;
  651.     char dummy[80];
  652.     char copy[80];
  653.  
  654.     strcpy(copy, string);
  655.     for(i=0; i<number; i++){
  656.     if(isInt)
  657.         ret = sscanf(copy,"%d %[^\n]", ((int *)field)+i, dummy);
  658.     else
  659.         ret = sscanf(copy,"%f %[^\n]", ((float *)field)+i, dummy);
  660.     strcpy(copy, dummy);
  661.     if(((ret!=2) && (i<number-1)) || ((ret==2) && (i==number-1))){
  662.         return FALSE;
  663.     }
  664.     }
  665.     return TRUE;
  666. }
  667.  
  668.  
  669.  
  670. /*****************************************************************************
  671.   FUNCTION : parseFile
  672.  
  673.   PURPOSE  : read the configuration file for snnsbat
  674.   RETURNS  : 
  675.   NOTES    :
  676.  
  677.   UPDATE   : 
  678. ******************************************************************************/
  679. static int parseFile(int op_code)
  680. {
  681.  
  682.     int   ret,dum_ret;
  683.     char  key[80],type[80],arg_string[80];
  684.     float result_param[2];
  685.  
  686.  
  687.     /* do configuration file scan */
  688.  
  689.     skipComments(file_in);
  690.  
  691.     if(exec_loop == 0){
  692.     ret = fscanf(file_in,"%s",key);
  693.     if(ret != 1 || !IsKey(key,"Type:")){
  694.         /* no file type given */
  695.         configError(1,"");
  696.     }
  697.     ret = fscanf(file_in,"%s",type);
  698.     if((strcmp(type,"SNNSBATCH_1") && strcmp(type,"SNNSBATCH_2"))){
  699.         /* wrong file type given */
  700.         configError(2,type);
  701.     }
  702.     skipComments(file_in);
  703.     }
  704.  
  705.     while((ret = fscanf(file_in,"%s",key)) != EOF){
  706.  
  707.     if(IsKey(key,"NoOfLearnParam:")){
  708.         NoOfLearnParamFlag = 1;
  709.         ret = fscanf(file_in,"%s",arg_string);
  710.         if(ret != 1)
  711.         configError(7,"NoOfLearnParam:");
  712.         if(IsOld(arg_string)){
  713.         if(exec_loop == 0)configError(8,"NoOfLearnParam:");
  714.         }else{
  715.         ret = sscanf(arg_string,"%d",&no_of_learn_param);
  716.         if(no_of_learn_param > NO_OF_LEARN_PARAMS){
  717.             if(!op_code)configError(12,"LEARN");
  718.             no_of_learn_param = NO_OF_LEARN_PARAMS;
  719.         }
  720.         }
  721.         if(learn_param_string[0] != '\0'){
  722.         if (!scanParameter(learn_param, learn_param_string, 
  723.                    no_of_learn_param,FALSE))
  724.             configError(3,"");
  725.         learn_param_string[0] = '\0';
  726.         }
  727.  
  728.     }else if(IsKey(key,"LearnParam:")){
  729.         LearnParamFlag = 1;
  730.         if(!no_of_learn_param){ /* value not read yet */
  731.         ret = fscanf(file_in,"%[^\n]",arg_string);
  732.         if(IsOld(arg_string)){
  733.             if(exec_loop == 0)configError(8,"LearnParam:");
  734.         }else
  735.             ret = sscanf(arg_string,"%[^\n]",learn_param_string);
  736.         if(ret != 1)
  737.             configError(7,"LearnParam:");
  738.         }else{
  739.         ret = fscanf(file_in,"%[^\n]",arg_string);
  740.         if(IsOld(arg_string)){
  741.             if(exec_loop == 0)configError(8,"LearnParam:");
  742.         }else{
  743.             if (!scanParameter(learn_param, arg_string, 
  744.                        no_of_learn_param,FALSE))
  745.             configError(3,"");
  746.         }
  747.         learn_param_string[0] = '\0';
  748.         }
  749.  
  750.     }else if(IsKey(key,"NoOfInitParam:")){
  751.         NoOfInitParamFlag = 1;
  752.         ret = fscanf(file_in,"%s",arg_string);
  753.         if(ret != 1)
  754.         configError(7,"NoOfInitParam:");
  755.         if(IsOld(arg_string)){
  756.         if(exec_loop == 0)configError(8,"NoOfInitParam:");
  757.         }else{
  758.         ret = sscanf(arg_string,"%d",&no_of_init_param);
  759.         if(no_of_init_param > NO_OF_INIT_PARAMS){
  760.             if(!op_code)configError(12,"INIT");
  761.             no_of_init_param = NO_OF_INIT_PARAMS;
  762.         }
  763.         }
  764.         if(init_param_string[0] != '\0'){
  765.         if (!scanParameter(init_param, init_param_string,
  766.                    no_of_init_param,FALSE))
  767.             configError(4,"init");
  768.         init_param_string[0] = '\0';
  769.         }
  770.  
  771.     }else if(IsKey(key,"InitParam:")){
  772.         InitParamFlag = 1;
  773.         if(!no_of_init_param){ /* value not read yet */
  774.         ret = fscanf(file_in,"%[^\n]",arg_string);
  775.         if(IsOld(arg_string)){
  776.             if(exec_loop == 0)configError(8,"InitParam:");
  777.         }else
  778.             ret = sscanf(arg_string,"%[^\n]",init_param_string);
  779.         if(ret != 1)
  780.             configError(7,"InitParam:");
  781.         }else{
  782.         ret = fscanf(file_in,"%[^\n]",arg_string);
  783.         if(IsOld(arg_string)){
  784.             if(exec_loop == 0)configError(8,"InitParam:");
  785.         }else{
  786.             if (!scanParameter(init_param, arg_string, 
  787.                        no_of_init_param,FALSE))
  788.             configError(4,"init");
  789.         }
  790.         init_param_string[0] = '\0';
  791.         }
  792.  
  793.     }else if(IsKey(key,"SubPatternISize:")){
  794.         SubPatternISizeFlag = 1;
  795.         if(NoOfVarDimFlag == 0){ /* value not read yet */
  796.         ret = fscanf(file_in,"%[^\n]",arg_string);
  797.         if(IsOld(arg_string)){
  798.             if(exec_loop == 0)configError(8,"SubPatternISize:");
  799.         }else
  800.             ret = sscanf(arg_string,"%[^\n]",SubPatternISize_string);
  801.         if(ret != 1)
  802.             configError(7,"SubPatternISize:");
  803.         }else{
  804.         ret = fscanf(file_in,"%[^\n]",arg_string);
  805.         if(IsOld(arg_string)){
  806.             if(exec_loop == 0)configError(8,"SubPatternISize:");
  807.         }else{
  808.             if (!scanParameter(SubPatternISize_param, arg_string, 
  809.                        no_of_var_dim[0],TRUE))
  810.             configError(4,"SubPatternISize:");
  811.         }
  812.         SubPatternISize_string[0] = '\0';
  813.         }
  814.  
  815.     }else if(IsKey(key,"SubPatternOSize:")){
  816.         SubPatternOSizeFlag = 1;
  817.         if(NoOfVarDimFlag == 0){ /* value not read yet */
  818.         ret = fscanf(file_in,"%[^\n]",arg_string);
  819.         if(IsOld(arg_string)){
  820.             if(exec_loop == 0)configError(8,"SubPatternOSize:");
  821.         }else
  822.             ret = sscanf(arg_string,"%[^\n]",SubPatternOSize_string);
  823.         if(ret != 1)
  824.             configError(7,"SubPatternOSize:");
  825.         }else{
  826.         ret = fscanf(file_in,"%[^\n]",arg_string);
  827.         if(IsOld(arg_string)){
  828.             if(exec_loop == 0)configError(8,"SubPatternOSize:");
  829.         }else{
  830.             if (!scanParameter(SubPatternOSize_param, arg_string, 
  831.                        no_of_var_dim[1],TRUE))
  832.             configError(4,"SubPatternOSize");
  833.         }
  834.         SubPatternOSize_string[0] = '\0';
  835.         }
  836.  
  837.     }else if(IsKey(key,"SubPatternIStep:")){
  838.         SubPatternIStepFlag = 1;
  839.         if(NoOfVarDimFlag == 0){ /* value not read yet */
  840.         ret = fscanf(file_in,"%[^\n]",arg_string);
  841.         if(IsOld(arg_string)){
  842.             if(exec_loop == 0)configError(8,"SubPatternIStep:");
  843.         }else
  844.             ret = sscanf(arg_string,"%[^\n]",SubPatternIStep_string);
  845.         if(ret != 1)
  846.             configError(7,"SubPatternIStep:");
  847.         }else{
  848.         ret = fscanf(file_in,"%[^\n]",arg_string);
  849.         if(IsOld(arg_string)){
  850.             if(exec_loop == 0)configError(8,"SubPatternIStep:");
  851.         }else{
  852.             if (!scanParameter(SubPatternIStep_param, arg_string, 
  853.                        no_of_var_dim[0],TRUE))
  854.             configError(4,"SubPatternIStep");
  855.         }
  856.         SubPatternIStep_string[0] = '\0';
  857.         }
  858.  
  859.     }else if(IsKey(key,"SubPatternOStep:")){
  860.         SubPatternOStepFlag = 1;
  861.         if(NoOfVarDimFlag == 0){ /* value not read yet */
  862.         ret = fscanf(file_in,"%[^\n]",arg_string);
  863.         if(IsOld(arg_string)){
  864.             if(exec_loop == 0)configError(8,"SubPatternOStep:");
  865.         }else
  866.             ret = sscanf(arg_string,"%[^\n]",SubPatternOStep_string);
  867.         if(ret != 1)
  868.             configError(7,"SubPatternOStep:");
  869.         }else{
  870.         ret = fscanf(file_in,"%[^\n]",arg_string);
  871.         if(IsOld(arg_string)){
  872.             if(exec_loop == 0)configError(8,"SubPatternOStep:");
  873.         }else{
  874.             if (!scanParameter(SubPatternOStep_param, arg_string, 
  875.                        no_of_var_dim[1],TRUE))
  876.             configError(4,"SubPatternOStep");
  877.         }
  878.         SubPatternOStep_string[0] = '\0';
  879.         }
  880.  
  881.     }else if(IsKey(key,"NoOfVarDim:")){
  882.         NoOfVarDimFlag = 1;
  883.         ret = fscanf(file_in,"%[^\n]",arg_string);
  884.         if(ret != 1)
  885.         configError(7,"NoOfVarDim:");
  886.         if(IsOld(arg_string)){
  887.         if(exec_loop == 0)configError(8,"NoOfVarDim:");
  888.         }else{
  889.         ret = sscanf(arg_string,"%d %d",&no_of_var_dim[0],
  890.                                     &no_of_var_dim[1]);
  891.         if(ret != 2)configError(17,"variable");
  892.         }
  893.         if(SubPatternISize_string[0] != '\0'){
  894.         if(!scanParameter(SubPatternISize_param,SubPatternISize_string,
  895.                    no_of_var_dim[0],TRUE))
  896.             configError(4,"SubPatternISize");
  897.         SubPatternISize_string[0] = '\0';
  898.         }
  899.         if(SubPatternOSize_string[0] != '\0'){
  900.         if(!scanParameter(SubPatternOSize_param,SubPatternOSize_string,
  901.                    no_of_var_dim[1],TRUE))
  902.             configError(4,"SubPatternOSize");
  903.         SubPatternOSize_string[0] = '\0';
  904.         }
  905.         if(SubPatternIStep_string[0] != '\0'){
  906.         if(!scanParameter(SubPatternIStep_param,SubPatternIStep_string,
  907.                    no_of_var_dim[0],TRUE))
  908.             configError(4,"SubPatternIStep");
  909.         SubPatternIStep_string[0] = '\0';
  910.         }
  911.         if(SubPatternOStep_string[0] != '\0'){
  912.         if(!scanParameter(SubPatternOStep_param,SubPatternOStep_string,
  913.                    no_of_var_dim[1],TRUE))
  914.             configError(4,"SubPatternOStep");
  915.         SubPatternOStep_string[0] = '\0';
  916.         }
  917.  
  918.     }else if(IsKey(key,"NetworkFile:")){
  919.         NetworkFileFlag = 1;
  920.         ret = fscanf(file_in,"%s",arg_string);
  921.         if(IsOld(arg_string)){
  922.         NetworkFileFlag = -1;
  923.         if(exec_loop == 0)configError(8,"NetworkFile:");
  924.         }else
  925.         strcpy(net_file, arg_string);
  926.  
  927.     }else if(IsKey(key,"TrainedNetworkFile:")){
  928.         TrainedNetworkFileFlag = 1;
  929.         ret = fscanf(file_in,"%s",arg_string);
  930.         if(IsOld(arg_string)){
  931.         TrainedNetworkFileFlag = -1;
  932.         if(exec_loop == 0)configError(8,"TrainedNetworkFile:");
  933.         }else
  934.         strcpy(trained_net_file, arg_string);
  935.  
  936.     }else if(IsKey(key,"LearnPatternFile:")){
  937.         LearnPatternFileFlag = 1;
  938.         ret = fscanf(file_in,"%s",arg_string);
  939.         if(IsOld(arg_string)){
  940.         LearnPatternFileFlag = -1;
  941.         if(exec_loop == 0)configError(8,"LearnPatternFile:");
  942.         if(PatternWarning && !op_code)configError(9,"");
  943.         }else
  944.         strcpy(learn_pat_file, arg_string);
  945.  
  946.     }else if(IsKey(key,"TestPatternFile:")){
  947.         TestPatternFileFlag = 1;
  948.         ret = fscanf(file_in,"%s",arg_string);
  949.         if(IsOld(arg_string)){
  950.         if(exec_loop == 0)configError(8,"TestPatternFile:");
  951.         }else
  952.         strcpy(test_pat_file, arg_string);
  953.  
  954.     }else if(IsKey(key,"ResultFile:")){
  955.         ResultFileFlag = 1;
  956.         ret = fscanf(file_in,"%s",arg_string);
  957.         if(IsOld(arg_string)){
  958.         if(exec_loop == 0)configError(8,"ResultFile:");
  959.         }else
  960.         strcpy(res_file, arg_string);
  961.  
  962.     }else if(IsKey(key,"InitFunction:")){
  963.         InitFunctionFlag = 1;
  964.         ret = fscanf(file_in,"%s",arg_string);
  965.         if(IsOld(arg_string)){
  966.         if(exec_loop == 0)configError(8,"InitFunction:");
  967.         }else
  968.         strcpy(init_func, arg_string);
  969.  
  970.     }else if(IsKey(key,"MaxLearnCycles:")){
  971.         MaxLearnCyclesFlag = 1;
  972.         ret = fscanf(file_in,"%s",arg_string);
  973.         if(IsOld(arg_string)){
  974.         if(exec_loop == 0)configError(8,"MaxLearnCycles:");
  975.         }else
  976.             ret = sscanf(arg_string,"%d",&no_of_cycles);
  977.         if(ret != 1)
  978.         configError(7,"MaxLearnCycles:");
  979.  
  980.     }else if(IsKey(key,"MaxErrorToStop:")){
  981.         MaxErrorToStopFlag = 1;
  982.         ret = fscanf(file_in,"%s",arg_string);
  983.         if(IsOld(arg_string)){
  984.         if(exec_loop == 0)configError(8,"MaxErrorToStop:");
  985.         }else
  986.             ret = sscanf(arg_string,"%f",&best_net_error);
  987.         if(ret != 1)
  988.         configError(7,"MaxErrorToStop:");
  989.  
  990.     }else if(IsKey(key,"Shuffle:")){
  991.         ShuffleFlag = 1;
  992.         dum_ret = getYesNoSwitch(file_in);
  993.         if(dum_ret == -1){
  994.         if(exec_loop == 0)configError(8,"Shuffle:");
  995.         }else
  996.         shuffle = dum_ret;
  997.         if(shuffle < -1)
  998.         configError(7,"Shuffle:");
  999.  
  1000.     }else if(IsKey(key,"ShuffleSubPat:")){
  1001.         ShuffleSubPatFlag = 1;
  1002.         dum_ret = getYesNoSwitch(file_in);
  1003.         if(dum_ret == -1){
  1004.         if(exec_loop == 0)configError(8,"ShuffleSubPat:");
  1005.         }else
  1006.         shuffleSubPat = dum_ret;
  1007.         if(shuffleSubPat < -1)
  1008.         configError(7,"ShuffleSubPat:");
  1009.  
  1010.     }else if(IsKey(key,"ResultMinMaxPattern:")){
  1011.         ResultMinMaxPatternFlag = 1;
  1012.         ret = fscanf(file_in,"%[^\n]",arg_string);
  1013.         if(IsOld(arg_string)){
  1014.         if(exec_loop == 0)configError(8,"ResultMinMaxPattern:");
  1015.         }else{
  1016.         if(scanParameter(result_param,arg_string,2,FALSE)){
  1017.             start_pattern = (int)result_param[0];
  1018.             end_pattern = (int)result_param[1];
  1019.         }else{
  1020.             configError(7,"ResultMinMaxPattern:");
  1021.         }
  1022.         }
  1023.     }else if(IsKey(key,"ResultIncludeInput:")){
  1024.         ResultIncludeInputFlag = 1;
  1025.         dum_ret = getYesNoSwitch(file_in);
  1026.         if(dum_ret == -1){
  1027.         if(exec_loop == 0)configError(8,"ResultIncludeInput:");
  1028.         }else
  1029.         input_included = dum_ret;
  1030.         if(input_included < -1)
  1031.         configError(7,"ResultIncludeInput:");
  1032.  
  1033.     }else if(IsKey(key,"ResultIncludeOutput:")){
  1034.         ResultIncludeOutputFlag = 1;
  1035.         dum_ret = getYesNoSwitch(file_in);
  1036.         if(dum_ret == -1){
  1037.         if(exec_loop == 0)configError(8,"ResultIncludeOutput:");
  1038.         }else
  1039.         output_included = dum_ret;
  1040.         if(output_included < -1)
  1041.         configError(7,"ResultIncludeOutput:");
  1042.  
  1043.     }else if(IsKey(key,"PerformActions:")){
  1044.         if( (no_of_var_dim[1] > 0 && !SubPatternOStepFlag) ||
  1045.         (no_of_var_dim[0] > 0 && !SubPatternIStepFlag))
  1046.         configError(16," ");
  1047.         if( (no_of_var_dim[1] > 0 && !SubPatternOSizeFlag) ||
  1048.         (no_of_var_dim[0] > 0 && !SubPatternISizeFlag))
  1049.         configError(15," ");
  1050.         if(!NoOfVarDimFlag && (SubPatternISizeFlag || SubPatternOSizeFlag ||
  1051.                    SubPatternIStepFlag || SubPatternOStepFlag))
  1052.         configError(18," ");
  1053.  
  1054.         if(!LearnPatternFileFlag && no_of_cycles)
  1055.         configError(6,"");
  1056.         PatternWarning = 0;
  1057.         if(TestPatternFileFlag)
  1058.         PatternWarning = 1;
  1059.  
  1060.         exec_loop += 1;
  1061.         if(op_code /* == read */){
  1062.         return(0);
  1063.         }else{
  1064.  
  1065.         if(LearnPatternFileFlag == -1 && NetworkFileFlag != -1)
  1066.             configError(14,"");
  1067.  
  1068.         if(!ResultFileFlag && (ResultMinMaxPatternFlag ||
  1069.            ResultIncludeInputFlag || ResultIncludeOutputFlag))
  1070.             configError(10,"");
  1071.  
  1072.         if(!InitFunctionFlag &&
  1073.                (InitParamFlag || NoOfInitParamFlag))
  1074.             configError(11,"");
  1075.  
  1076.         /* reset keywords for correct syntax check */
  1077.         init_param_string[0]      = '\0';
  1078.         learn_param_string[0]     = '\0';
  1079.         SubPatternISize_string[0] = '\0';
  1080.         SubPatternOSize_string[0] = '\0';
  1081.         SubPatternIStep_string[0] = '\0';
  1082.         SubPatternISizeFlag       = 0;
  1083.         SubPatternOSizeFlag       = 0;
  1084.         SubPatternIStepFlag       = 0;
  1085.         SubPatternOStepFlag       = 0;
  1086.         NoOfVarDimFlag            = 0;
  1087.         no_of_init_param          = 0;
  1088.         no_of_learn_param         = 0;
  1089.         net_file[0]               = '\0';
  1090.         trained_net_file[0]       = '\0';
  1091.         learn_pat_file[0]         = '\0';
  1092.         test_pat_file[0]          = '\0';
  1093.         res_file[0]               = '\0';
  1094.         init_func[0]              = '\0';
  1095.         no_of_cycles              = 0;
  1096.         best_net_error            = 0.0;
  1097.         LearnPatternFileFlag      = 0;
  1098.         TestPatternFileFlag       = 0;
  1099.                 ResultFileFlag            = 0;
  1100.                 ResultMinMaxPatternFlag   = 0;
  1101.                 ResultIncludeInputFlag    = 0;
  1102.                 ResultIncludeOutputFlag   = 0;
  1103.                 InitFunctionFlag          = 0;
  1104.                 InitParamFlag             = 0;
  1105.                 NoOfInitParamFlag         = 0;
  1106.         }
  1107.     }else{
  1108.         /* Found unknown key in configuration file */
  1109.         skipRestOfLine(file_in);
  1110.         configError(5,key);
  1111.     }
  1112.     skipComments(file_in);
  1113.  
  1114.     }/* end while */
  1115.  
  1116.     exec_loop += 1;
  1117.     if(!(op_code) /* == parse */){
  1118.  
  1119.     if(PatternWarning && IsOld(learn_pat_file))
  1120.         configError(9,"");
  1121.  
  1122.     if( (no_of_var_dim[1] > 0 && !SubPatternOStepFlag) ||
  1123.        (no_of_var_dim[0] > 0 && !SubPatternIStepFlag))
  1124.         configError(16," ");
  1125.     if( (no_of_var_dim[1] > 0 && !SubPatternOSizeFlag) ||
  1126.        (no_of_var_dim[0] > 0 && !SubPatternISizeFlag))
  1127.         configError(15," ");
  1128.     if(!NoOfVarDimFlag && (SubPatternISizeFlag || SubPatternOSizeFlag ||
  1129.                    SubPatternIStepFlag || SubPatternOStepFlag))
  1130.         configError(18," ");
  1131.  
  1132.     rewind(file_in);
  1133.  
  1134.     if(!ResultFileFlag && (ResultMinMaxPatternFlag ||
  1135.        ResultIncludeInputFlag || ResultIncludeOutputFlag))
  1136.         configError(10,"");
  1137.  
  1138.     if(!InitFunctionFlag && (InitParamFlag || NoOfInitParamFlag))
  1139.         configError(11,"");
  1140.  
  1141.  
  1142.     /* reset keywords for correct subsequent read */
  1143.  
  1144.     init_param_string[0]  = '\0';
  1145.     learn_param_string[0] = '\0';
  1146.     no_of_init_param      = 0;
  1147.     no_of_learn_param     = 0;
  1148.     net_file[0]           = '\0';
  1149.     trained_net_file[0]   = '\0';
  1150.     learn_pat_file[0]     = '\0';
  1151.     test_pat_file[0]      = '\0';
  1152.     res_file[0]           = '\0';
  1153.     init_func[0]          = '\0';
  1154.     no_of_cycles          = 0;
  1155.     best_net_error        = 0.0;
  1156.     }
  1157.     return(1);
  1158. }
  1159.  
  1160.  
  1161.  
  1162. /*****************************************************************************
  1163.   FUNCTION : trainNet
  1164.  
  1165.   PURPOSE  : perform network training
  1166.   RETURNS  : 
  1167.   NOTES    :
  1168.  
  1169.   UPDATE   : 
  1170. ******************************************************************************/
  1171. static void trainNet()
  1172. {
  1173.  
  1174.     int ret,step,dummy;
  1175.  
  1176.  
  1177.     errChk(krui_DefTrainSubPat(SubPatternISize_param,SubPatternOSize_param,
  1178.                    SubPatternIStep_param,SubPatternOStep_param,
  1179.                    &dummy));
  1180.  
  1181.     fprintf(file_out,
  1182.         "\n  epoch:         SSE            MSE            SSE/o-units\n\n");
  1183.     
  1184.     step = ((no_of_cycles-1) / NO_OF_CYCLES_DISPLAYED)+1;
  1185.     while((cycle < no_of_cycles) && 
  1186.       ((cycle && (return_values[0] > best_net_error)) || !cycle)){
  1187.     if(shuffle){        /*  shuffle patterns every cycle  */
  1188.         ret = krui_shufflePatterns(TRUE);
  1189.         errChk(ret);
  1190.     }
  1191.     if(shuffleSubPat){    /*  shuffle subpatterns every cycle  */
  1192.         ret = krui_shuffleSubPatterns(TRUE);
  1193.         errChk(ret);
  1194.     }
  1195.  
  1196.     /**************************************************************
  1197.     *  REMEMBER:  return_values[0] returns the current net error  *
  1198.     *  learn_param[0] contains the 1st learning parameter         *
  1199.     **************************************************************/
  1200.     ret = krui_learnAllPatterns(learn_param, NO_OF_LEARN_PARAMS, 
  1201.                     &return_values, &no_of_return_values );
  1202.     errChk(ret);
  1203.  
  1204.     /* print the return values of the learning function  */
  1205.     if ((cycle % step == 0) || cycle == no_of_cycles)
  1206.         writeLearnFuncValues();
  1207.  
  1208.     /* get user cpu time */
  1209.     (void) times(&tp);
  1210.  
  1211.     if(((tp.tms_utime-lasttime) / HZ_value) >= SAVE_PERIOD){
  1212.         /*  save temporary network  */
  1213.         if(++tmp_switch & 1)
  1214.         ret = krui_saveNet(tmp_file1,netname);
  1215.         else
  1216.         ret = krui_saveNet(tmp_file2,netname);
  1217.         errChk(ret);
  1218.  
  1219.         if(tmp_switch == 1){
  1220.         fprintf(file_out,
  1221.             "\n#####  Temporary network file '%s' created.  #####\n\n",
  1222.             tmp_file1);
  1223.         fflush(file_out);
  1224.         }
  1225.         if(tmp_switch == 2){
  1226.         fprintf( file_out,
  1227.             "\n#####  Temporary network file '%s' created.  #####\n\n",
  1228.             tmp_file2);
  1229.         fflush(file_out);
  1230.         }
  1231.         lasttime = tp.tms_utime;
  1232.     }
  1233.     cycle++;
  1234.     }
  1235.  
  1236.  
  1237.     /* print the return values of the learning function  */
  1238.     if (cycle < no_of_cycles)
  1239.     writeLearnFuncValues();
  1240.  
  1241.  
  1242. }
  1243.  
  1244.  
  1245.  
  1246. /*****************************************************************************
  1247.   FUNCTION : computeResultfile
  1248.  
  1249.   PURPOSE  : perform result file computation
  1250.   RETURNS  : 
  1251.   NOTES    :
  1252.  
  1253.   UPDATE   : 
  1254. ******************************************************************************/
  1255. static void computeResultfile()
  1256. {
  1257.  
  1258.     int ret,dummy;
  1259.  
  1260.  
  1261.     if(test_pat_file[0] == '\0' && learn_pat_file[0] == '\0'){
  1262.     fprintf(stderr,"No pattern file present !!\n");
  1263.     exit(0);
  1264.     }
  1265.  
  1266.     /* load test pattern file */
  1267.  
  1268.     if(test_pat_file[0] != '\0' && strcmp(test_pat_file,learn_pat_file) != 0){ 
  1269.     ret = krui_loadNewPatterns(test_pat_file,&dummy);
  1270.     errChk(ret);
  1271.     fprintf(file_out,"\n\nTest Pattern File '%s' loaded.\n",test_pat_file);
  1272.     no_of_patterns = krui_getNoOfPatterns();
  1273.     fprintf(file_out,"No. of test patterns: %d\n\n",no_of_patterns);
  1274.     }
  1275.  
  1276.     /* create result file */
  1277.  
  1278.     if(!start_pattern && !end_pattern){
  1279.     start_pattern = 1;
  1280.     end_pattern = no_of_patterns;
  1281.     }
  1282.     errChk(krui_DefTrainSubPat(SubPatternISize_param,SubPatternOSize_param,
  1283.                    SubPatternIStep_param,SubPatternOStep_param,
  1284.                    &dummy));
  1285.     ret = krui_saveResult(res_file,TRUE,start_pattern,end_pattern,
  1286.               input_included,output_included);
  1287.     errChk(ret);
  1288.     fprintf(file_out,"\nResult file saved.\n");
  1289.  
  1290. }
  1291.  
  1292.  
  1293.  
  1294.  
  1295. /*****************************************************************************
  1296.   FUNCTION : main
  1297.  
  1298.   PURPOSE  : perform batch processing with the SNNS kernel
  1299.   RETURNS  : 
  1300.   NOTES    :
  1301.  
  1302.   UPDATE   : 
  1303. ******************************************************************************/
  1304. int main(int argc, char  *argv[] )
  1305. {
  1306.     int            ret, i, dummy,
  1307.                 pError,
  1308.                 notLast=1;
  1309.     time_t    clock;
  1310.  
  1311.  
  1312.  
  1313.     /* set configuration and log file names */
  1314.  
  1315.     switch (argc)  {
  1316.       case 1:
  1317.     strcpy( config_file, "snnsbat.cfg" );
  1318.     strcpy( log_file, "snnsbat.log" );
  1319.     break;
  1320.       case 2:
  1321.     strcpy( config_file, argv[1] );
  1322.     strcpy( log_file, "snnsbat.log" );
  1323.     break;
  1324.       case 3:
  1325.     strcpy( config_file, argv[1] );
  1326.     strcpy( log_file, argv[2] );
  1327.     break;
  1328.       default:
  1329.     fprintf( stderr, "Usage: %s [config_file [log_file]]\n", argv[0] );
  1330.     exit( 1 );
  1331.     }
  1332.  
  1333.  
  1334.     /* get HZ value */
  1335.  
  1336.     if((getenv("HZ") == NULL) || (sscanf(getenv("HZ"),"%d",&HZ_value)!=1)){
  1337. #ifndef HZ
  1338.     fprintf( stderr, "****  WARNING: no HZ defined!\n" );
  1339.     HZ_value = 100;
  1340. #else
  1341.     HZ_value = HZ;
  1342. #endif
  1343.     }
  1344.  
  1345.  
  1346.     /*  open configuration file  */
  1347.  
  1348.     if((file_in = fopen(config_file,"r")) == NULL){
  1349.     fprintf(stderr,"Can't open configuration file '%s'\n",config_file);
  1350.     exit(1);
  1351.     }
  1352.  
  1353.  
  1354.     /* parse configuration files for errors */
  1355.  
  1356.     fprintf(stdout,"Parsing the configuration file .... ");fflush(stdout);
  1357.     pError = parseFile(0);
  1358.     exec_loop = 0;
  1359.     if(SyntaxError){
  1360.     fprintf(stderr,"\n\nFound %d errors in the configuraton file\n",
  1361.         SyntaxError);
  1362.     exit(1);
  1363.     }
  1364.     if(SyntaxWarning)
  1365.     fprintf(stderr,"\n\nFound %d problems in the configuraton file\n",
  1366.         SyntaxWarning);
  1367.     else
  1368.     fprintf(stdout,"Correct\n");
  1369.  
  1370.  
  1371.     /* open Log-file */
  1372.  
  1373.     if((file_out = fopen(log_file,"w")) == NULL){
  1374.     fprintf(stderr,"Can't open LOG file\n");
  1375.     exit(1);
  1376.     }
  1377.  
  1378.  
  1379.     /* begin loggin */
  1380.  
  1381.     fprintf(stdout,"\n%s\n", krui_getVersion() );
  1382.     fprintf(stdout,"-----  SNNS batch execution run  -----\n\n" );
  1383.     fprintf(file_out,"%s Batchlearning Program\n",krui_getVersion());
  1384.     fprintf(file_out,"Configuration file: '%s'\n",config_file);
  1385.     fprintf(file_out,"Log file          : '%s'\n\n",log_file);
  1386.  
  1387.  
  1388.     /*  create names for temporary files */
  1389.  
  1390.     tmp_file1 = tempnam("./","SNNS_");
  1391.     tmp_file2 = tempnam("./","SNNS_");
  1392.  
  1393.  
  1394.     /* perform the batch program */
  1395.  
  1396.     while(notLast){
  1397.  
  1398.  
  1399.     /*  clear all flags */
  1400.  
  1401.     InitParamFlag = 0;
  1402.     LearnParamFlag = 0;
  1403.     NoOfInitParamFlag = 0;
  1404.     NoOfLearnParamFlag = 0;
  1405.     NoOfVarDimFlag = 0;
  1406.     NetworkFileFlag = 0;
  1407.     TrainedNetworkFileFlag = 0;
  1408.     LearnPatternFileFlag = 0;
  1409.     TestPatternFileFlag = 0;
  1410.     ResultFileFlag = 0;
  1411.     InitFunctionFlag = 0;
  1412.     MaxLearnCyclesFlag = 0;
  1413.     ResultMinMaxPatternFlag = 0;
  1414.     ShuffleFlag = 0;
  1415.     ShuffleSubPatFlag = 0;
  1416.     ResultIncludeInputFlag = 0;
  1417.     ResultIncludeOutputFlag = 0;
  1418.  
  1419.  
  1420.     /* read parameters for next execution loop */
  1421.  
  1422.         pError = parseFile(1);
  1423.     if(pError)notLast = 0;
  1424.  
  1425.  
  1426.     /* clear unused  keyword values */
  1427.     
  1428.     if(!InitParamFlag){    
  1429.         init_param_string[0]  = '\0';
  1430.         for(i=0; i<NO_OF_INIT_PARAMS; i++) 
  1431.            init_param[i] = 0.0;
  1432.     }
  1433.     if(!LearnParamFlag){    
  1434.         learn_param_string[0] = '\0';
  1435.         for(i=0; i<NO_OF_LEARN_PARAMS; i++) 
  1436.            learn_param[i] = 0.0;
  1437.     }
  1438.     if(!NoOfInitParamFlag)
  1439.         no_of_init_param      = 0;
  1440.     if(!NoOfLearnParamFlag)
  1441.         no_of_learn_param     = 0;
  1442.     if(!NoOfVarDimFlag)
  1443.         no_of_var_dim[0] =  
  1444.         no_of_var_dim[1]  = 0;
  1445.     if(!NetworkFileFlag)
  1446.         net_file[0]           = '\0';
  1447.     if(!TrainedNetworkFileFlag)
  1448.         trained_net_file[0]   = '\0';
  1449.     if(!LearnPatternFileFlag)
  1450.         learn_pat_file[0]     = '\0';
  1451.     if(!TestPatternFileFlag)
  1452.         test_pat_file[0]      = '\0';
  1453.     if(!ResultFileFlag)
  1454.         res_file[0]           = '\0';
  1455.     if(!InitFunctionFlag)    
  1456.         init_func[0]          = '\0';
  1457.     if(!MaxLearnCyclesFlag)
  1458.         no_of_cycles          = 0;
  1459.     if(!MaxErrorToStopFlag)
  1460.         best_net_error        = 0.0;
  1461.     if(!ResultMinMaxPatternFlag){
  1462.         start_pattern         = 0;
  1463.         end_pattern           = 0;
  1464.     }
  1465.     if(!ShuffleFlag)
  1466.         shuffle               = 0;
  1467.     if(!ShuffleSubPatFlag)
  1468.         shuffleSubPat         = 0;
  1469.     if(!ResultIncludeInputFlag)
  1470.         input_included        = 0;
  1471.     if(!ResultIncludeOutputFlag)    
  1472.         output_included       = 1;
  1473.  
  1474.     tmp_switch            = 0;
  1475.     cycle                 = 0;
  1476.  
  1477.  
  1478.     /* dump header */
  1479.  
  1480.     fprintf( file_out,"\n\n\n########");
  1481.     fprintf( file_out," SNNS batch execution run. Loop %d ", exec_loop );
  1482.     fprintf( file_out,"########\n");
  1483.  
  1484.  
  1485.     /* load the network */
  1486.  
  1487.     if(NetworkFileFlag != -1){
  1488.         ret = krui_loadNet(net_file,&netname);
  1489.         errChk(ret);
  1490.         fprintf(file_out,"Networkfile '%s' loaded.\n",net_file);
  1491.     }
  1492.  
  1493.     
  1494.     /* load learn pattern file */
  1495.  
  1496.     if(LearnPatternFileFlag > 0){
  1497.         ret = krui_loadNewPatterns(learn_pat_file,&dummy);
  1498.         errChk(ret);
  1499.         fprintf(file_out,"Patternfile '%s' loaded.\n",learn_pat_file);
  1500.         no_of_patterns = krui_getNoOfPatterns();
  1501.         fprintf(file_out,"No. of patterns: %d\n\n",no_of_patterns);
  1502.         fprintf(file_out,"No. of cycles: %d\n\n", no_of_cycles);
  1503.         fprintf(file_out,
  1504.             "Max. network error to stop: %f\n\n",best_net_error);
  1505.         if(shuffle)
  1506.         fprintf(file_out,"Patterns are shuffled\n");
  1507.         else
  1508.         fprintf(file_out,"Patterns are in order\n");
  1509.         if(shuffleSubPat)
  1510.         fprintf(file_out,"Subpatterns are shuffled\n");
  1511.  
  1512.         fprintf(file_out,"\n");
  1513.     }
  1514.  
  1515.  
  1516.     /* log the initial settings */
  1517.  
  1518.     do_initial_log();
  1519.  
  1520.  
  1521.     /*  init cpu time  */
  1522.  
  1523.     (void)times(&tp);
  1524.     lasttime = tp.tms_utime;
  1525.  
  1526.  
  1527.     /* start timer */
  1528.  
  1529.     clock = 1;
  1530.     (void)time(&clock);
  1531.     starttime = clock;
  1532.     if(no_of_cycles)
  1533.         fprintf(file_out,"\n%s Batchlearning started at %s\n",
  1534.             krui_getVersion(),ctime(&clock));
  1535.     else
  1536.         fprintf(file_out,"\n%s Result file computation started at %s\n",
  1537.             krui_getVersion(),ctime(&clock));
  1538.  
  1539.  
  1540.     /*  catch signals  */
  1541.  
  1542.     catchSignals();
  1543.  
  1544.  
  1545.     /* initialize net */
  1546.  
  1547.     if(init_func[0] != '\0'){
  1548.         ret = krui_setInitialisationFunc(init_func);
  1549.         errChk(ret);
  1550.         ret = krui_initializeNet(init_param,NO_OF_INIT_PARAMS);
  1551.         errChk(ret);
  1552.         fprintf(file_out, "\nNetwork initialized with\n%s ",init_func);
  1553.         for(i=0; i<no_of_init_param; i++)
  1554.         fprintf(file_out,"%4.2f ",init_param[i]);
  1555.         fprintf(file_out,"\n");
  1556.     }
  1557.  
  1558.  
  1559.     /* train the net */
  1560.  
  1561.     if(LearnPatternFileFlag)
  1562.         trainNet();
  1563.  
  1564.  
  1565.     /* perform result file computation */
  1566.  
  1567.     if(ResultFileFlag)
  1568.         computeResultfile();
  1569.  
  1570.  
  1571.     /*  save the network */
  1572.  
  1573.     if(trained_net_file[0] == '\0'){
  1574.         fprintf(file_out, "\nTrained Network was not saved \n");
  1575.     }else{
  1576.         ret = krui_saveNet(trained_net_file,netname);
  1577.         errChk(ret);
  1578.         fprintf(file_out,"\nNetwork saved to %s.\n",trained_net_file);
  1579.     }
  1580.  
  1581.  
  1582.     /* remove temporary files */
  1583.  
  1584.     if(tmp_switch >= 1){
  1585.         if(unlink(tmp_file1) == 0){
  1586.         fprintf(file_out, 
  1587.               "\n#####  Temporary network file '%s' removed.  #####\n",
  1588.                tmp_file1);
  1589.         fflush(file_out);
  1590.         }
  1591.         if(tmp_switch > 1){
  1592.         if(unlink(tmp_file2) == 0){
  1593.             fprintf(file_out, 
  1594.             "#####  Temporary network file '%s' removed.  #####\n",
  1595.                 tmp_file2);
  1596.             fflush(file_out);
  1597.         }
  1598.         }
  1599.     }
  1600.  
  1601.  
  1602.     /* write statistics */
  1603.  
  1604.     if(LearnPatternFileFlag)
  1605.         writeStatistics(NORMAL);
  1606.  
  1607.     } /* while(notLast) */
  1608.  
  1609.     fclose(file_out);
  1610.     fclose(file_in);
  1611.  
  1612.     fprintf(stdout,"\n%s Batchlearning has terminated successfully.\n",
  1613.         krui_getVersion());
  1614.     fprintf(stdout,"Logfile '%s' written.\n",log_file);
  1615.  
  1616.     return(0);
  1617. }
  1618.