home *** CD-ROM | disk | FTP | other *** search
/ Power Programming / powerprogramming1994.iso / progtool / educaton / inf_src.arc / INFERENC.STR < prev    next >
Text File  |  1986-03-14  |  5KB  |  239 lines
  1. /*
  2. **
  3. **    This is the inference engine for which the rule compiler
  4. **    has the task of compiling the rules into a knowledge base
  5. **    This knowledge base has the following parts:
  6.  
  7.         hypstack consisting of a stack of integers, each
  8.         of which points to the offset into the rule base
  9.         which is a hypothesis.
  10.         
  11.         rule base consisting of an orderd set of flags and
  12.         pointers, each comprising a single rule statement.
  13.         Each flag identifies the type of rule and the pointer
  14.         points to the specific string within the string buffer
  15.         which accompanied the rule keyword.
  16.         
  17.         the keywords are defined in the rule compiler documentation
  18.         so look there for it.
  19.         
  20.         
  21. **
  22. **
  23. **
  24. */
  25.  
  26. /*********************INFERENCE ENGINE STRUCTURE******************/
  27.  
  28. /*
  29. **   MAIN VERIFICATION DRIVER
  30. **
  31.  
  32. MAIN(ARGC,ARGV)
  33. {
  34. READ ALL DATA FROM COMPILED RULES INTO INTERNAL BUFFERS
  35. CLEAR THE KNOWN TRUE AND KNOWN FALSE STACKS
  36. WHILE(ALL CONSEQUENT NOT DONE)
  37.     {
  38.     POP A CONSEQUENT OFF OF THE CONSEQUENT STACK (INVERSE ORDER)
  39.     IF((CONSEQUENT IS KNOWN TRUE) OR (CONSEQUENT IS KNOWN FALSE))
  40.         {
  41.         CONTINUE
  42.         }
  43.     VERIFY(CONSEQUENT) 
  44.     IF(CONSEQUENT IS TRUE)
  45.         {
  46.         IF(CONSEQUENT.FLAG == ROUTINE_TRUE)
  47.             {
  48.             IF(CONSEQUENT IS NOT KNOWN TRUE OR 
  49.                  CONSEQUENT IS NOT KNOWN FALSE)
  50.                 {
  51.                 PRINT RUNNING CONSEQUENT (CONSEQUENT)
  52.                 RESULT = RUN ROUTINE (CONSEQUENT)
  53.                 TELL USER RESULT OF RUN
  54.                 }
  55.             }
  56.         ELSE
  57.             {
  58.             TELL USER THE TRUTH AND OR CONCLUSION
  59.             }
  60.         }
  61.     }
  62. IF(NO CONSEQUENT WAS PROVEN)
  63.     {
  64.     TELL USER "CANNOT PROVE ANYTHING"
  65.     }
  66. }
  67. **
  68. **
  69. */
  70.  
  71. /*
  72. **
  73. **    VERIFY A PARTICULAR CONSEQUENT
  74. **
  75.  
  76. VERIFY(CONSEQUENT)  (RECURSIVE VERIFY OF THE CONSEQUENT)
  77. {
  78. GET ALL ANTECEDENTS FOR CONSEQUENT ONTO STACK
  79. IF(THERE ARE NO ANTECEDENTS FOR THE CONSEQUENT)
  80.     {
  81.     PRINT "BAD CONSEQUENT -- HAS NO ANTECEDENTS"
  82.     RETURN(TRUE)
  83.     }
  84. WHILE(ALL ANTECEDENTS FOR CONSEQUENT NOT PROVED)
  85.     {
  86.     POP ANTECEDENT OFF OF STACK
  87.     IF(ANTECEDENT IS CONSEQUENT)
  88.         {
  89.         IF(CONSEQUENT IS KNOWN FALSE)
  90.             {
  91.             RETURN(FALSE)
  92.             }
  93.         IF(CONSEQUENT IS KNOWN TRUE)
  94.             {
  95.             CONTINUE
  96.             }
  97.         VERIFY(CONSEQUENT)
  98.         IF(CONSEQUENT IS TRUE)
  99.             {
  100.             IF(CONSEQUENT.FLAG == ROUTINE_TRUE)
  101.                 {
  102.                 PRINT RUNNING CONSEQUENT (CONSEQUENT)
  103.                 RESULT = RUN ROUTINE (CONSEQUENT)
  104.                 IF (RESULT == FALSE)
  105.                     {
  106.                     RETURN(FALSE)
  107.                     }
  108.                 }
  109.             ELSE
  110.                 {
  111.                 PUT CONSEQUENT ON KNOWN TRUE STACK
  112.                 }
  113.             CONTINUE
  114.             }
  115.         ELSE
  116.             {
  117.             PUT CONSEQUENT ON KNOWN FALSE STACK
  118.             RETURN(FALSE)
  119.             }
  120.         }
  121.     ELSE
  122.         {
  123.         IF(ANTECEDENT IS KNOWN TRUE)
  124.             {
  125.             CONTINUE
  126.             }
  127.         IF(ANTECEDENT IS KNOWN FALSE)
  128.             {
  129.             RETURN (FALSE)
  130.             }
  131.         SWITCH(ANTECEDENT.FLAG):
  132.             {
  133.             CASE (STRING_TRUE) :
  134.                 RESULT = GET TRUTH FOR STATEMNT (ANTECEDENT)
  135.                 IF(RESULT == FALSE)
  136.                     {
  137.                     RETETURN (FALSE)
  138.                     }
  139.                 BREAK ;
  140.             CASE (STRING_FALSE) :
  141.                 RESULT = GET TRUTH FOR STATEMNT (ANTECEDENT)
  142.                 IF(RESULT == TRUE)
  143.                     {
  144.                     RETURN(FALSE)
  145.                     }
  146.                 BREAK ;
  147.             CASE (ROUTINE_TRUE) : 
  148.                 PRINT "RUNNING ROUTINE --"
  149.                 PRINT STRING POINTED TO BY ANTECEDENT.STRING
  150.                 RESULT = RUN ROUTINE (ANTECEDENT)
  151.                 IF(RESULT == FALSE)
  152.                     {
  153.                     RETURN (FALSE)
  154.                     }
  155.                 BREAK ;
  156.             CASE (ROUTINE_FALSE) : 
  157.                 PRINT "RUNNING ROUTINE --"
  158.                 PRINT STRING POINTED TO BY ANTECEDENT.STRING
  159.                 RESULT = RUN ROUTINE(ANTECEDENT)
  160.                 IF(TRUE)
  161.                     {
  162.                     RETURN(FALSE)
  163.                     }
  164.                 BREAK ;
  165.             DEFAULT:
  166.                 'DIS IS SOME PROBLEM MAMA!
  167.             }
  168.         }
  169.     }
  170. RETURN(TRUE)
  171. }
  172.  
  173. **
  174. **
  175. */
  176.  
  177. /*
  178. **
  179. **    ROUTINE FOR GETTING TRUTH OUT OF USER
  180. **    PRINTS STRING AND ASKS FOR WHETHER IT IS TRUE OR FALSE
  181. **
  182.  
  183. GET TRUTH FOR STATEMNT(ANTECEDENT)
  184. {
  185. PRINT "IS THE FOLLOWING TRUE?"
  186. PRINT STATEMENT AT ANTECEDENT.STRING
  187. GET USER RESPONSE (YES, WHY OR NO)
  188. DO FOREVER
  189.     {
  190.     IF(USER RESPONSE IS YES)
  191.         {
  192.         PLACE ANTECEDENT IN KNOWN TRUE STACK
  193.         RETURN(TRUE)
  194.         }
  195.     IF(USER RESPONSE IS NO)
  196.         {
  197.         PLACE ANTECEDENT IN KNOW FALSE STACK
  198.         RETETURN (FALSE)
  199.         }
  200.     IF(USER RESPONSE IS WHY)
  201.         {
  202.         PRINT OUT CONSEQUENT/ANTECEDENT STACK IN A NICE FORMAT
  203.         }
  204.     }
  205. }
  206. **
  207. **
  208. */
  209.  
  210. /*
  211. **
  212. **    ROUTINE TO TEST THE TRUTH OF A ROUTINE
  213. **
  214.  
  215.  
  216. RUN ROUTINE (ANTECEDENT)
  217. {
  218. SPAWN THE ROUTINE NAMED IN THE STRING POINTED TO BY ANTECEDENT.STRING
  219. WAIT FOR ROUTINE TO FINISH
  220. GET RESULT OF THE ROUTINE
  221. IF(RESULT OF ROUTINE IS TRUE)
  222.     {
  223.     PLACE ANTECEDENT IN KNOWN TRUE STACK
  224.     RETURN(TRUE)
  225.     }
  226. ELSE
  227.     {
  228.     PLACE ANTECEDENT IN KNOWN FALSE STACK
  229.     RETURN (FALSE)
  230.     }
  231. }
  232.  
  233. **
  234. **
  235. **
  236. */
  237.  
  238.  
  239.