home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NASANETS.ZIP / PARSER.C < prev    next >
C/C++ Source or Header  |  1990-06-07  |  57KB  |  1,366 lines
  1. /*=============================*/
  2. /*           NETS              */
  3. /*                             */
  4. /* a product of the AI Section */
  5. /* NASA, Johnson Space Center  */
  6. /*                             */
  7. /* principal author:           */
  8. /*       Paul Baffes           */
  9. /*                             */
  10. /* contributing authors:       */
  11. /*      Bryan Dulock           */
  12. /*      Chris Ortiz            */
  13. /*=============================*/
  14.  
  15.  
  16. /*
  17. ----------------------------------------------------------------------
  18.   Code For Construction Of Net Structures (Prefix = PS_)
  19. ----------------------------------------------------------------------
  20.   This code is divided into 4 major sections:
  21.  
  22.   (1) include files
  23.   (2) externed functions
  24.   (3) global variables
  25.   (4) subroutines
  26.  
  27.   Each section is further explained below.
  28. ----------------------------------------------------------------------
  29. */
  30.  
  31.  
  32. /*
  33. ----------------------------------------------------------------------
  34.   INCLUDE FILES
  35. ----------------------------------------------------------------------
  36. */
  37. #include "common.h"
  38. #include "netio.h"
  39.  
  40.  
  41. /*
  42. ----------------------------------------------------------------------
  43.   MACRO DEFINITIONS
  44. ----------------------------------------------------------------------
  45.   Below are eight different macros used for range checking while the
  46.   network spec file is being parsed. Each commands in the file takes
  47.   a numeric argument, and these macros can check ranges for any of the
  48.   eight possible cases given an upper bound (u) and a lower bound (l)
  49.   on the number "n". 
  50. ----------------------------------------------------------------------
  51. */
  52. #define GTLT(n,l,u)  (((n) >  (l) && (n) <  (u)) ? 1 : 0)
  53. #define GELT(n,l,u)  (((n) >= (l) && (n) <  (u)) ? 1 : 0)
  54. #define GTLE(n,l,u)  (((n) >  (l) && (n) <= (u)) ? 1 : 0)
  55. #define GELE(n,l,u)  (((n) >= (l) && (n) <= (u)) ? 1 : 0)
  56.  
  57. #define LTGT(n,l,u)  (((n) <  (l) || (n) >  (u)) ? 1 : 0)
  58. #define LEGT(n,l,u)  (((n) <= (l) || (n) >  (u)) ? 1 : 0)
  59. #define LTGE(n,l,u)  (((n) <  (l) || (n) >= (u)) ? 1 : 0)
  60. #define LEGE(n,l,u)  (((n) <= (l) || (n) >= (u)) ? 1 : 0)
  61.  
  62.  
  63. /*
  64. ----------------------------------------------------------------------
  65.   EXTERNED FUNCTIONS AND GLOBALS
  66. ----------------------------------------------------------------------
  67.   Below are the functions defined in other files which are used by the
  68.   code here. They are organized by section.
  69. ----------------------------------------------------------------------
  70. */
  71. extern Sint      C_float_to_Sint();
  72. extern char     *sys_alloc();
  73. extern FILE     *PA_open_binary();
  74. extern int       PA_put_to_workfile();
  75. extern void      PA_flush();
  76. extern void      IO_print();
  77.  
  78. extern char      IO_str[MAX_LINE_SIZE];
  79.  
  80.  
  81. /*
  82. ----------------------------------------------------------------------
  83.   GLOBAL VARIABLES
  84. ----------------------------------------------------------------------
  85.   First, some markers which are used by several routines and are just
  86.   declared here a globals for convenience. A parsing variable is next,
  87.   called "use_last_command" which is needed for the parsing of layer
  88.   specifications. It determines whether or not to reuse the last 
  89.   command read in during the parsing. Then come two globals which are
  90.   used during the creation of a network to indicate whether or not a
  91.   global learning rate and/or momentum has been used. If so, then these
  92.   two globals will contain the floating point equivalent of the given
  93.   values.
  94. ----------------------------------------------------------------------
  95. */
  96. static int     line_count = 1;   /* used by parse_iopairs, PS_get_token */
  97. static char    last_char;        /* holds the last character read in    */
  98. static char    last_str[MAX_LINE_SIZE];   /* holds last command read in */
  99. static int     use_last_command = FALSE;  /* used for layer parse (see  */
  100.                                           /* PS_get_command).           */
  101. float          global_learn_base;   /* used during parse to set default */
  102. float          global_momentum;     /* global learn/momentum values     */
  103.  
  104.  
  105. /*
  106. ======================================================================
  107.   ROUTINES IN PARSER.C                                                   
  108. ======================================================================
  109.   The routines in this file are grouped below by function.  Each routine
  110.   is prefixed by the string "PS_" indicating that it is defined in the 
  111.   "parser.c" file.  The types returned by the routines are also shown 
  112.   here so that cross checking is more easily done between these functions
  113.   and the other files which intern them.
  114.  
  115.  
  116.   Type Returned                 Routine                                 
  117.   -------------                 -------                                 
  118.     void                        PS_reset_for_layer_parse
  119.     int                         PS_global_spec_check
  120.     Layer_spec *                PS_get_layer
  121.     void                        PS_get_learn_values
  122.     void                        PS_get_nodes
  123.     void                        PS_get_node_dimensions
  124.     void                        PS_get_target
  125.     void                        PS_get_pattern
  126.     int                         PS_get_command
  127.     void                        PS_print_command
  128.     int                         PS_range_check
  129.     int                         PS_int_check
  130.     int                         PS_parse_iopairs
  131.     int                         PS_check_items
  132.     int                         PS_skip_tokens
  133.     int                         PS_get_token
  134.     int                         PS_get_float_from_file
  135. ======================================================================
  136. */
  137.  
  138.  
  139. void  PS_reset_for_layer_parse()
  140. /*
  141. ----------------------------------------------------------------------
  142.   The only thing done here, as of now, is to set the global variable
  143.   'use_last_command' to FALSE. This must be done from the OUTSIDE via
  144.   this routine because the global is static to this file.
  145. ----------------------------------------------------------------------
  146. */
  147. BEGIN
  148.    use_last_command = FALSE;
  149.  
  150. END /* PS_reset_for_layer_parse */
  151.  
  152.  
  153. int  PS_global_spec_check(ptr_file)
  154. FILE  *ptr_file;
  155. /*
  156. ----------------------------------------------------------------------
  157.  This routine checks for the existence of two optional specs located 
  158.   at the very beginning of a network specification file. They are the
  159.   GLOBAL-LEARN-RATE and GLOBAL-MOMENTUM respectively. Either or both
  160.   of these may be specified by the user. If they are present, they 
  161.   define default values for the learn_base and momemtum elements of 
  162.   each layer. These values may be overridden later by using the 
  163.   LEARN-RATE, SCALE-FACTOR, or MOMENTUM commands for each layer which
  164.   needs overriding.
  165.   
  166.   Returns ERROR if EOF encountered while trying to check for these 
  167.   first two optional commands.
  168. ----------------------------------------------------------------------
  169. */
  170. BEGIN
  171.    float  num;
  172.    int    temp, PS_get_command(), PS_range_check();
  173.    void   PS_print_command();
  174.    
  175.    /*--------------------------------------*/
  176.    /* first, set the global values to -1.0 */
  177.    /* symbolizing UNKNOWN values           */
  178.    /*--------------------------------------*/
  179.    global_learn_base = UNDEFINED;
  180.    global_momentum   = UNDEFINED;
  181.    
  182.    /*-----------------------------------*/
  183.    /* loop on PS_get_command, until you */
  184.    /* hit EOF or a LAYER command.       */
  185.    /*-----------------------------------*/
  186.    temp = PS_get_command(ptr_file, &num);
  187.    while (temp != LAYER) BEGIN
  188.       if (temp == EOF) BEGIN
  189.          sprintf(IO_str, "\n*** ERROR: no specifications found in file");
  190.          IO_print(0);
  191.          return(ERROR);
  192.       ENDIF
  193.       else if (temp == GLOBAL_LEARN_RATE) BEGIN
  194.          if (PS_range_check( GTLE(num, 0, LEARN_MAX) ) == OK)
  195.             global_learn_base = num;
  196.       ENDELSE
  197.       else if (temp == GLOBAL_MOMENTUM) BEGIN
  198.          if (PS_range_check( GELE(num, 0, MOMENTUM_MAX) ) == OK)
  199.             global_momentum = num;
  200.