home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NASANETS.ZIP / SYSDEP.C < prev    next >
C/C++ Source or Header  |  1990-06-07  |  11KB  |  392 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.   All System-Dependent Code Resides Here (Prefix = sys_)
  19. ----------------------------------------------------------------------
  20.   This code is divided into 4 major sections:
  21.  
  22.   (1) include files
  23.   (2) subroutines
  24.  
  25.   Each section is further explained below.
  26. ----------------------------------------------------------------------
  27. */
  28.  
  29.  
  30. /*
  31. ----------------------------------------------------------------------
  32.   INCLUDES AND EXTERNS
  33. ----------------------------------------------------------------------
  34. */
  35. #include     "common.h"
  36. #include     "weights.h"
  37. #include     "layer.h"
  38. #include     "net.h"
  39. #include     "netio.h"
  40. extern void  IO_print();
  41. extern char  IO_str[MAX_LINE_SIZE];
  42.  
  43.  
  44. /*
  45. ======================================================================
  46.   ROUTINES IN SYSDEP.C                                                   
  47. ======================================================================
  48.   The routines in this file are grouped below by function.  Each routine
  49.   is prefixed by the string "sys_" indicating that it is defined in the 
  50.   "sysdep.c" file.  The types returned by the routines are also shown here
  51.   so that cross checking is more easily done between these functions
  52.   and the other files which intern them.
  53.  
  54.  
  55.   Type Returned                 Routine                                 
  56.   -------------                 -------                                 
  57.     char *                      sys_long_alloc
  58.     char *                      sys_alloc
  59.     void                        sys_long_free
  60.     void                        sys_free
  61.     float                       sys_get_time
  62.     void                        sys_init_rand
  63.     void                        sys_delete_file
  64.     void                        sys_rename_file
  65. ======================================================================
  66. */
  67.  
  68.  
  69. char  *sys_long_alloc(size)
  70. long  size;
  71. /*
  72. ----------------------------------------------------------------------
  73.   Although not really system dependent code, the get_mem routine was
  74.   placed here because its activities are usually associated with system
  75.   calls. All this routine does is take the place of "malloc" so that
  76.   I can check for lack of space and handle the error gracefully, ie,
  77.   by printing out a message before quiting the program.
  78.   
  79.   The trick here is to do the right kind of malloc. Normally, the 
  80.   typical "malloc" function which comes with the compiler takes an
  81.   unsigned integer as an argument. Thus you cannot pass it a long 
  82.   argument. 
  83. ----------------------------------------------------------------------
  84. */
  85. BEGIN
  86.    char          *r, *sys_check_alloc();
  87.    unsigned int  test;
  88.    
  89.    /*-----------------------------------------*/
  90.    /* allocate the memory in chars, using the */
  91.    /* proper routine depending on compiler    */
  92.    /*-----------------------------------------*/
  93.    if (size > 0)
  94. #if LSPEED
  95.       r = mlalloc(size);
  96. #endif  
  97.  
  98. #if IBM_TBC
  99.       r = farmalloc(size);
  100. #endif
  101.  
  102. #if IBM_MSC
  103.       r = halloc(size,1);
  104. #endif
  105.   
  106. #if (! LSPEED) && (! IBM_TBC) && (! IBM_MSC)
  107.    BEGIN
  108.       test = (unsigned int) size;
  109.       if (test != size)
  110.          r= NULL;
  111.       else r = (char *) malloc(test);
  112.    ENDIF
  113. #endif
  114.  
  115.    else 
  116.       r = NULL;
  117.    
  118.    /*---------------------------------------------*/
  119.    /* then check to see that the memory was there */
  120.    /*---------------------------------------------*/
  121.    return(sys_check_alloc(r));
  122.       
  123. END /* sys_long_alloc */
  124.  
  125.  
  126. char  *sys_alloc(size)
  127. unsigned int  size;
  128. /*
  129. ----------------------------------------------------------------------
  130.   This routine is called for memory allocation when the caller KNOWS
  131.   that a large memory allocation is not necessary.
  132. ----------------------------------------------------------------------
  133. */
  134. BEGIN
  135.    char  *r, *sys_check_alloc();
  136.  
  137.    if (size > 0)
  138.       r = (char *) malloc(size);
  139.    else 
  140.       r = NULL;
  141.    return(sys_check_alloc(r));
  142.       
  143. END /* sys_alloc */
  144.  
  145.  
  146. char  *sys_check_alloc(ptr_mem)
  147. char  *ptr_mem;
  148. /*
  149. ----------------------------------------------------------------------
  150.   Just a subroutine called by the allocation routines above to check if
  151.   the pointer to memory is NULL. If so, then out of memory, thus exit
  152.   the program.
  153. ----------------------------------------------------------------------
  154. */
  155. BEGIN
  156.    /*---------------------------------------*/
  157.    /* if the result is NULL exit with error */
  158.    /*---------------------------------------*/
  159.    if (ptr_mem == NULL) BEGIN
  160.       sprintf(IO_str, "\n*** out of memory ***\n");
  161.       IO_print(0);
  162.       exit(1);
  163.    ENDIF
  164.    return(ptr_mem);
  165.       
  166. END /* sys_check_alloc */
  167.  
  168.   
  169. void  sys_long_free(ptr)
  170. char *ptr;
  171. /*
  172. ----------------------------------------------------------------------
  173.   This free routine is the sister of the sys_get_mem routine. It calls
  174.   the proper routine for freeing the memory, depending upon the compiler
  175.   used. 
  176. ----------------------------------------------------------------------
  177. */
  178. BEGIN
  179.  
  180. #if LSPEED
  181.    free(ptr);
  182. #endif  
  183.   
  184. #if IBM_TBC
  185.    farfree(ptr);
  186. #endif
  187.  
  188. #if IBM_MSC
  189.    hfree(ptr);
  190. #endif
  191.  
  192. #if (! LSPEED) && (! IBM_TBC) && (! IBM_MSC)
  193.    free(ptr);
  194. #endif
  195.  
  196. END /* sys_long_free */
  197.  
  198.  
  199. void  sys_free(ptr)
  200. char  *ptr;
  201. /*
  202. ----------------------------------------------------------------------
  203.   Just to keep everything parallel, I wrote this "normal case" free 
  204.   routine which is the sister to the sys_alloc routine above. All this 
  205.   does is call the generic free routine of the system.
  206. ----------------------------------------------------------------------
  207. */
  208. BEGIN
  209.    free(ptr);
  210.    
  211. END /* sys_free */
  212.  
  213.  
  214. float  sys_get_time()                          
  215. /*
  216. ----------------------------------------------------------------------
  217.  float sys_get_time()                                                     
  218.                                                                       
  219.  Returns a floating point value of the current time.  Taken from      
  220.   the CLIPS code, which is written in a more portable form there.     
  221.  Note that there are several '#if' statements here.  These look for   
  222.   values defined within 'common.h' to see whether or not they should  
  223.   compile.  That is, if "VMS" is defined to 1 then any code           
  224.   surrounded by a '#if VMS' statement will be compiled.  This is a    
  225.   simple way to make code portable.                                   
  226. ----------------------------------------------------------------------
  227. */
  228. BEGIN
  229. #if   VMS || IBM_MSC || UNIX_BER
  230.    float sec, msec, time;
  231.    long   temp;
  232.    struct timeb time_pointer;
  233.  
  234.    ftime(&time_pointer);
  235.    temp = time_pointer.time;
  236.    temp = temp - ((temp/10000) * 10000);
  237.    sec  = (float) temp;
  238.    msec = (float) time_pointer.millitm;
  239.    return(sec + (msec / 1000.0));
  240. #endif
  241.  
  242. #if   UNIX_ATT 
  243.    long t_int;
  244.    float t;
  245.    struct tms buf;
  246.  
  247.    t_int = times(&buf);
  248.    t = (float) t_int / 60.0;
  249.    return(t);
  250. #endif
  251.  
  252. #if   IBM_TBC
  253.    struct time  now;
  254.    float        t;
  255.    
  256.    gettime(&now);
  257.    t = ((float)now.ti_hour * 3600.0)
  258.        + ((float)now.ti_min * 60.0)
  259.        + (float)now.ti_sec;
  260.    return(t);
  261. #endif
  262.  
  263. #if   LSPEED
  264.    struct tm  *now;
  265.    float        t;
  266.    
  267.    now = localtime(0L);
  268.    t = ((float)now->tm_hour * 3600.0)
  269.        + ((float)now->tm_min * 60.0)
  270.        + (float)now->tm_sec;
  271.    return(t);
  272. #endif
  273.  
  274. #if  WIZARD
  275.    time_t  the_time;
  276.    
  277.    return( (float)time(&the_time) );
  278. #endif
  279.  
  280. END /* sys_get_time */
  281.  
  282.  
  283. void  sys_init_rand()
  284. /*
  285.