ai.cpp.txt

人工智能程序源码

   AudVal.pho = pho;
   AudVal.act = act;
   AudVal.pov = pov;
   AudVal.beg = beg;
   AudVal.ctu = ctu;
   AudVal.psi = psi;
   DB::SetEle(AudValPtr,t);
   }

// Set data into Psi array (fiber).
   
void EN::SetPsiData(int t, int psi, int act, int jux, int pre,
   				           int pos, int seq, int enx)
   {
   PsiStr PsiVal;
   PsiStr * PsiValPtr = & PsiVal;
   PsiVal.psi = psi;
   PsiVal.act = act;
   PsiVal.jux = jux;
   PsiVal.pre = pre;
   PsiVal.pos = pos;
   PsiVal.seq = seq;
   PsiVal.enx = enx;
   DB::SetEle(PsiValPtr,t);
   }
   
// Set data into En array (fiber).

void EN::SetEnData(int t, int nen, int act, int fex,
   				          int pos, int fin, int aud)
   {
   EnStr EnVal;
   EnStr * EnValPtr = & EnVal; 
   EnVal.nen = nen;
   EnVal.act = act;
   EnVal.fex = fex;
   EnVal.pos = pos;
   EnVal.fin = fin;
   EnVal.aud = aud;
   DB::SetEle(EnValPtr,t);
   }

// Initialize arrays (fibers)

void EN::Enb()
   { 
   SetAudData(1,'Y',0,35,1,0,0);
   SetAudData(2,'E',0,35,0,1,0);
   SetAudData(3,'S',0,35,0,1,0);
   SetPsiData(3,32,0,0,0,4,0,32);
   SetEnData(3,32,0,32,4,32,1);

   SetAudData(5,'I',0,35,1,0,0);
   SetAudData(6,'F',0,35,0,1,20);
   SetPsiData(6,20,0,0,0,3,0,20);
   SetEnData(6,20,0,20,3,20,5);

   SetAudData(8,'T',0,35,1,0,0);
   SetAudData(9,'H',0,35,0,1,0);
   SetAudData(10,'E',0,35,0,1,7);
   SetPsiData(10,7,0,0,0,1,0,7);
   SetEnData(10,7,0,7,1,7,8);

   SetAudData(12,'T',0,35,1,0,0);
   SetAudData(13,'R',0,35,0,1,0);
   SetAudData(14,'U',0,35,0,1,0);
   SetAudData(15,'T',0,35,0,1,0);
   SetAudData(16,'H',0,35,0,1,68);
   SetPsiData(16,68,0,0,0,5,66,68);
   SetEnData(16,68,0,68,5,68,12);

   SetAudData(18,'I',0,35,1,0,0);
   SetAudData(19,'S',0,35,0,1,66);
   SetPsiData(19,66,0,0,68,8,1,66);
   SetEnData(19,66,0,66,8,66,18);

   SetAudData(21,'T',0,35,1,0,0);
   SetAudData(22,'H',0,35,0,1,0);
   SetAudData(23,'A',0,35,0,1,0);
   SetAudData(24,'T',0,35,0,1,22);
   SetPsiData(24,22,0,0,0,3,0,22);
   SetEnData(24,22,0,22,3,22,21);

   SetAudData(26,'A',0,35,1,0,0);
   SetAudData(27,'L',0,35,0,1,0);
   SetAudData(28,'L',0,35,0,1,2);
   SetPsiData(28,2,0,0,0,1,0,2);
   SetEnData(28,2,0,2,1,2,26);

   SetAudData(30,'R',0,35,1,0,0);
   SetAudData(31,'O',0,35,0,1,0);
   SetAudData(32,'B',0,35,0,1,0);
   SetAudData(33,'O',0,35,0,1,0);
   SetAudData(34,'T',0,35,0,1,0);
   SetAudData(35,'S',0,35,0,1,39);
   SetPsiData(35,39,0,0,0,5,0,39);
   SetEnData(35,39,0,39,5,39,30);

   SetAudData(37,'A',0,35,1,0,0);
   SetAudData(38,'R',0,35,0,1,0);
   SetAudData(39,'E',0,35,0,0,67);
   SetPsiData(39,67,0,0,39,8,38,67);
   SetEnData(39,67,0,67,8,67,37);

   SetAudData(41,'P',0,35,1,0,0);
   SetAudData(42,'E',0,35,0,1,0);
   SetAudData(43,'R',0,35,0,1,0);
   SetAudData(44,'S',0,35,0,1,0);
   SetAudData(45,'O',0,35,0,1,0);
   SetAudData(46,'N',0,35,0,1,0);
   SetAudData(47,'S',0,35,0,0,38);
   SetPsiData(47,38,0,0,0,5,0,39);
   SetEnData(47,38,0,38,5,38,41);
   DB::SetTime(47);
   }

// Initialize the word search list
   
void EN::Ena()
   {
   char * WrdPtr;
   char string[] = " YES IF THE TRUTH IS THAT ROBOTS ";
   WrdPtr = DB::GetWrdPtr();
   strcpy(WrdPtr,string);         
   }

****************************** EN.CPP file ends *****************
EN.H
AI.H
SN.H
SE.H
DB.H
AI.CPP
SE.CPP
EN.CPP
DB.CPP
SN.CPP
********** DB.CPP file begins ***********************************
// Member function definitions of the DB class.
// For reference only.                  9/16/03

// Data Base - Creates and manipulates AI
// memory arrays. Currently 1 dimensional
// fixed length. Should be variable length
// and a linked list to allow convenient
// insertion and deletion. Deletion 
// currently just clears the location.
// Should also be asociative memory.
// Hashing would help.


#include <iomanip.h>

#include "AI.h"   
#include "DB.h"

   int Time;              // Time index to words

   PsiStr * PsiAryPtr;    // Pointer to start of Psi array (fiber).
   EnStr  * EnAryPtr;     // Pointer to start of En array (fiber).
   AudStr * AudAryPtr;    // Pointer to start of Aud array (fiber).
   char   * WrdAryPtr;    // Pointer to start of Word list.
   
   DB::DB()
   {
   // Use extensible Array class here
   // rather than fixed size array
   if((PsiAryPtr = new PsiStr[ARYSIZ]) == (PsiStr *)0)
       PrintMemErr();
   if((EnAryPtr  = new EnStr[ARYSIZ]) == (EnStr *)0)
       PrintMemErr();
   if((AudAryPtr = new AudStr[ARYSIZ]) == (AudStr *)0)
       PrintMemErr(); 
   ClrPsi();   // Clears Psi array (Tabulrasa equivalent)                     
   ClrEn();    // Clears En  array (Tabulrasa equivalent)                    
   ClrAud();   // Clears Aud array (Tabulrasa equivalent)                     
   if((WrdAryPtr = new char[WRDSIZ]) == (char *)0)
       PrintMemErr();
   ClrWrd(); // Clears Word List
   }
   
   DB::~DB()
   {
   delete [] PsiAryPtr;
   delete [] EnAryPtr;
   delete [] AudAryPtr;
   delete [] WrdAryPtr;
   }
        
   PsiStr * DB::GetPsiAryPtr()   // Get Psi beginning pointer
   {
   return(PsiAryPtr);
   }

   EnStr * DB::GetEnAryPtr()     // Get En beginning pointer
   {
   return(EnAryPtr);
   }

   AudStr * DB::GetAudAryPtr()   // Get Aud beginning pointer
   {
   return(AudAryPtr);
   }

   char * DB::GetWrdPtr()        // Get word list beginning pointer
   {
   return(WrdAryPtr);
   }
   
   void DB::PrintMemErr()        // Memory error message
   {
   cout << "\nArray creation error\n";
   }
   
   // Set functions
   // Templates to be used for data base functions
   
    BOOL DB::SetEle(PsiStr * StrPtr, const int EleIdx)    // Set concept array element
   	{                                                     // This is the Instantiate module
   	(PsiAryPtr+EleIdx)->psi = StrPtr->psi;
   	(PsiAryPtr+EleIdx)->act = StrPtr->act;
   	(PsiAryPtr+EleIdx)->jux = StrPtr->jux;
  	(PsiAryPtr+EleIdx)->pre = StrPtr->pre;
   	(PsiAryPtr+EleIdx)->pos = StrPtr->pos;
   	(PsiAryPtr+EleIdx)->seq = StrPtr->seq;
   	(PsiAryPtr+EleIdx)->enx = StrPtr->enx; 
    return(True);
   	}
 				
   BOOL DB::SetEle(EnStr  * StrPtr, const int EleIdx)   // set english lexicon element, element index
   	{                                                   // This is the EnVocab module
   	(EnAryPtr+EleIdx)->nen = StrPtr->nen;              
   	(EnAryPtr+EleIdx)->act = StrPtr->act;
   	(EnAryPtr+EleIdx)->fex = StrPtr->fex;
  	(EnAryPtr+EleIdx)->pos = StrPtr->pos;
   	(EnAryPtr+EleIdx)->fin = StrPtr->fin;
   	(EnAryPtr+EleIdx)->aud = StrPtr->aud;
    return(True);
   	}

   BOOL DB::SetEle(AudStr * StrPtr, const int EleIdx)   // set auditory memory element, element index
   	{
   	(AudAryPtr+EleIdx)->pho = StrPtr->pho;
   	(AudAryPtr+EleIdx)->act = StrPtr->act;
   	(AudAryPtr+EleIdx)->pov = StrPtr->pov;
  	(AudAryPtr+EleIdx)->beg = StrPtr->beg;
   	(AudAryPtr+EleIdx)->ctu = StrPtr->ctu;
   	(AudAryPtr+EleIdx)->psi = StrPtr->psi;
    return(True);
   	}

   // get functions 
   
   PsiStr * DB::GetPsiEle( const int EleIdx)   // return concept array element 
   	{
   	return(GetPsiAryPtr() + EleIdx);
   	}
   	
   EnStr * DB::GetEnEle( const int EleIdx)   // return english lexicon element
   	{
   	return(GetEnAryPtr() + EleIdx);
   	} 

   AudStr * DB::GetAudEle( const int EleIdx)   // return auditory memory element
   	{
   	return(GetAudAryPtr() + EleIdx);
   	}

   // delete functions
   
   BOOL DB::DelPsi( const int EleIdx); // delete concept array element, element index
   BOOL DB::DelEn(  const int EleIdx); // delete english lexicon element, element index
   BOOL DB::DelAud( const int EleIdx); // delete auditory memory element, element index
   
   // print functions 
   
   BOOL DB::PrintPsiElements();  // output
   BOOL DB::PrintEnElements();   // output 
   BOOL DB::PrintAudElements();  // output
   
   BOOL DB::SetTime(int t)       // Set Time
   {
   if((t < 65000) && (t >= 0))
       {
       Time = t;
       return(True);
       }
   else
   	   return(False);
   }
                                 
   int DB::GetTime()             // Get Time
   {
   return(Time);
   }

   void DB::StartupMsg()
   {
   cout << "\nThis software is not waranteed to perform any function.\n" << endl;
   }


 
   void DB::ClrPsi()    // Clears Psi array (Tabulrasa equivalent)  
   {
   int i;
   PsiStr PsiZer;
   PsiStr * PsiZerPtr = & PsiZer; 
   PsiZer.psi = 0;
   PsiZer.act = 0;
   PsiZer.jux = 0;
   PsiZer.pre = 0;
   PsiZer.pos = 0;
   PsiZer.seq = 0;
   PsiZer.enx = 0;
   for( i=0;i<ARYSIZ;i++)
   		DB::SetEle(PsiZerPtr,i);		    ; 
   }
   
   void DB::ClrEn()     // Clears En array (Tabulrasa equivalent)  
   {
   int i;
   EnStr EnZer;
   EnStr * EnZerPtr = & EnZer; 
   EnZer.nen = 0;
   EnZer.act = 0;
   EnZer.fex = 0;
   EnZer.pos = 0;
   EnZer.fin = 0;
   EnZer.aud = 0; 
   for( i=0;i<ARYSIZ;i++)
   		DB::SetEle(EnZerPtr,i);		    
   }
   
   void DB::ClrAud()   // Clears Aud array (Tabulrasa equivalent)  
   {
   int i;
   AudStr AudZer;
   AudStr * AudZerPtr = & AudZer; 
   AudZer.pho = ' ';
   AudZer.act = 0;
   AudZer.pov = 0;
   AudZer.beg = 0;
   AudZer.ctu = 0;
   AudZer.psi = 0; 
   for( i=0;i<ARYSIZ;i++)
   		DB::SetEle(AudZerPtr,i);		    ; 
   } 
   
   void DB::ClrWrd()     // Clears word list  
   {
   int i;
   for(i=0;i<WRDSIZ;i++)
   		*(WrdAryPtr + i) = ' ';
   }

****************************** DB.CPP file ends *****************
EN.H
AI.H
SN.H
SE.H
DB.H
AI.CPP
SE.CPP
EN.CPP
DB.CPP
SN.CPP
********** SN.CPP file begins ***********************************

// Member function definitions of the SN class.
// Sensorium - For reference only.    9/16/03


#include <iomanip.h>
#include <ctype.h> 
#include <stdlib.h>
#include <string.h>

#include "AI.h"   
#include "SN.h"
#include "DB.h"
#include "EN.h" 
  

   SN::SN()        // Sensorium class constructor
   {
   }               // Sensorium class destructor
   SN::~SN()
   {
   }

   void SN::Sen()  // Human input module with AI attention
   {
   RequestMsg();   // Get Human Input
   ClrActTags();   // Clear Active Tags
   Audition();     // Process Human Input
   } 

   void SN::RequestMsg()   // Get Human Input
   {
   cout << "Enter a brief positive or negative unpunctuated sentence." << endl;
   cout << "The AI listens for an input, and then generates a thought.\n" << endl;
   cout << "Enter an * to exit the AI.\n" << endl;
   cout << "Human: "; 
   ClrBuf();
   cin.getline(Buf,BUFLEN,'\n');
   }
   
   void SN::ClrActTags()
   {
   AudStr * AudPtr;
   int t = DB::GetTime();
   for (int i = 0;iact = 0;
        }
   }
   
   void SN::Audition()  // AI attention
   {
   int idx = 0;
   int onset; // Beginning of word
   char * tokenptr;  
   if(Buf[0] == '*')    // If first character is * then exit program
      {
      cout << "\nUser Halt.\n" << endl;
      exit(0);
      }
   ConvUpper();         // Convert all characters in message to upper case   
   idx = ClrSpc(idx);   // Skip any leading spaces in messge
   
   // Process words and characters by propagating effect of old
   // words into Psi data base and adding new words and propagating
   // their presence into the Psi data base. 
   
   tokenptr = strtok(Buf," ");
   tokenptr = tokenptr + idx; // Adjust pointer to skip leading spaces
   while(tokenptr != NULL)    // Extract words
   		 {
   		 cout << tokenptr << endl;
         if(AudRecog(tokenptr)) // Test for word in data base list
   				{
   				OldConcept();  // Word is in data base so update concept
   				} 
   		    else
   				{   
   				onset = AddWrdDb(tokenptr); // Add word to data base and return start time
   				AddWrdDbList(tokenptr); // Add word to data base list
   				NewConcept(onset);           // Update concept of new word
   				}
          tokenptr = strtok(NULL, " "); 
          }
   }
   
// Find the index to the first character of the 
// character string str embedded in the character
// string s.

    int SN::Find (const char * str, char * s) const
	{
	char * s2 = strstr(s,str);
	if (s2) 
	   return (s2 - s);
	else
	   return(-1);
    }

   void SN::ClrBuf()    // Clear the input buffer
   {
    int i = 0;
    for(i=0;i<BUFLEN;i++)
        Buf[i] = NULL;
    }

   
   void SN::ConvUpper()    // Convert input to upper case
   {
   for(int i =0;i<BUFLEN;i++)
      Buf[i] = (char) toupper(Buf[i]);
   }

   int SN::ClrSpc(int i)  // Find index for first non space character
   {
   while(Buf[i] == ' ')
       {
       i++;
       }            
   return(i);
   }

   BOOL SN::AudRecog(char * tokenptr)  // Test for word in data data base list
   { 
   int i,len;
   char * Wrd;
   Wrd = DB::GetWrdPtr();
   i = SN::Find(tokenptr,Wrd);
   if(i<0) 
       return(False);
   if(*(Wrd + i - 1) != ' ')     
       return(False);
   len = strlen(tokenptr);
   if(*(Wrd + i + len) != ' ')
       return(False);
   return(True);
   }

   
   void SN::OldConcept()   // Update arrays (fibers) for existing word (concept)
   {
   SN::Parser();
   SN::Activate();
   }
   
   void SN::NewConcept(int onset)   // Update arrays (fibers) for new  word (concept)
   {
   int t;
   t = DB::GetTime();
   EN::SetPsiData(t,1,31,0,0,5,0,1);      
   EN::SetEnData(t,1,31,1,5,1,onset);    
   }
   
   void SN::Parser()
   {
   }
   
   void SN::Activate()
   {
   }              
  
   
   int SN::AddWrdDb(char * tokenptr)  // Add a word to the Aud array (fiber).
	{
	int t,i,wrdlen,onset;
    wrdlen = strlen(tokenptr);  		
    t = DB::GetTime();
   	t = t + 2;  // Leave blank in data base and set time for new word start 
   	onset = t;  // Save the new word start time
   	EN::SetAudData(t,*(tokenptr),0,35,1,0,0);  // Set first letter
    if(wrdlen >= 1)
   		{
   		for(i=1;i<wrdlen;i++)
   			{
   		    EN::SetAudData(t,*(tokenptr+i),0,35,0,1,0);
   		    t++;
   		    }
   		DB::SetTime(t);
   		}
   	return(onset);
   	}			
 
    void SN::AddWrdDbList(char * tokenptr)  // Add a word to the word search list
	{;
    char * WrdList;
    WrdList = DB::GetWrdPtr();
    strcat(WrdList,tokenptr);
    strcat(WrdList," ");
   	}