nevrax.org : docs

00001 /* Copyright, 2000 Nevrax Ltd.
+00002  *
+00003  * This file is part of NEVRAX <MODULE_NAME>.
+00004  * NEVRAX <MODULE_NAME> is free software; you can redistribute it and/or modify
+00005  * it under the terms of the GNU General Public License as published by
+00006  * the Free Software Foundation; either version 2, or (at your option)
+00007  * any later version.
+00008 
+00009  * NEVRAX <MODULE_NAME> is distributed in the hope that it will be useful, but
+00010  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00012  * General Public License for more details.
+00013 
+00014  * You should have received a copy of the GNU General Public License
+00015  * along with NEVRAX <MODULE_NAME>; see the file COPYING. If not, write to the
+00016  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00017  * MA 02111-1307, USA.
+00018  */
+00019 
+00020 
+00021 #include "nel/ai/logic/fo_assert.h"
+00022 #include "nel/ai/logic/fo_operator.h"
+00023 #include "nel/ai/logic/valueset.h"
+00024 #include "nel/ai/logic/varset.h"
+00025 #include "nel/ai/logic/fact.h"
+00026 #include "nel/ai/logic/clause.h"
+00027 #include "nel/ai/agent/agent_digital.h"
+00028 
+00029 namespace NLAILOGIC
+00030 {
+00031         using namespace NLAIAGENT;
+00032 
+00033         CFirstOrderAssert::CFirstOrderAssert(const IVarName &n, sint32 nb_vars) : IBaseAssert( n )
+00034         {
+00035                 _NbVars = nb_vars;
+00036 /*              std::vector<IBaseVar *> *lv = new std::vector<IBaseVar *>;
+00037                 for (sint32 i = 0; i < _NbVars; i++)
+00038                         lv->pushBack(NULL);*/
+00039         }
+00040 
+00041 
+00042         CFirstOrderAssert::CFirstOrderAssert(const CFirstOrderAssert &cp) : IBaseAssert( *cp._Name )
+00043         {
+00044 
+00045                 CConstIteratorContener r = _Facts.getConstIterator();
+00046                 while( !r.isInEnd() )
+00047                 {
+00048                         _Facts.pushBack( 50, (CValueSet *) (*r).clone() );
+00049                 }
+00050         }
+00051 
+00052         CFirstOrderAssert::~CFirstOrderAssert()
+00053         {
+00054                 while ( _Facts.size() )
+00055                 {
+00056                         _Facts.Front()->release();
+00057                         _Facts.popFront();
+00058                 }
+00059         }
+00060 
+00061         void CFirstOrderAssert::connectClause(CClause *, std::vector<sint32> &)
+00062         {
+00063         }
+00064 
+00065         void CFirstOrderAssert::addFact(CVarSet *f)
+00066         {
+00067                 // Lorsqu'on ajoute un fait, le transmet à toutes les conditions qui en dépendent avec la position des variables dans la condition
+00068                 for ( sint32 i = 0; i < (sint32)_Outputs.size(); i++ )
+00069                 {
+00070                         // Créé la liste des valeurs
+00071                         std::list<IObjetOp *> *values = f->getValues(); 
+00072 
+00073 //                      TODO: unifier pour bool et first order operator
+00074 //                      (CFirstOrderOperator *) _Outputs[i]->propagate(values, _PosVars[i] );
+00075                         delete values;
+00076                 }
+00077                 
+00078                 _Facts.pushBack( 50, f->asCValueSet() );
+00079         }
+00080 
+00081         void CFirstOrderAssert::addFact(CValueSet *f)
+00082         {
+00083                 // Lorsqu'on ajoute un fait, le transmet à toutes les conditions qui en dépendent avec la position des variables dans la condition
+00084                 for ( sint32 i = 0; i < (sint32)_Outputs.size(); i++ )
+00085                 {
+00086                         // Créé la liste des valeurs
+00087 //                      std::list<IObjectIA *> *values = f->getValues();
+00088 //                      TODO: unifier pour bool et first order operator                 
+00089 //                      _Outputs[i]->propagate(values, _PosVars[i] );
+00090                 }
+00091 
+00092                 _Facts.pushBack( 50, (CValueSet *) f->clone() );
+00093         }
+00094 
+00095         void CFirstOrderAssert::removeFact(CFact *f)
+00096         {
+00097                 std::vector<IBaseOperator *>::iterator it_cl = _Outputs.begin();
+00098                 while ( it_cl != _Outputs.end() )
+00099                 {
+00100                         // doit passer par un envoi de message!!!
+00101                         it_cl++;
+00102                 }
+00103 
+00104                 CValueSet *tmp = f->asValueSet();
+00105 
+00106                 CConstIteratorContener it_f = _Facts.getConstIterator();
+00107                 while( !it_f.isInEnd() )
+00108                 {
+00109                         if ( *f == *(CValueSet *)((const IObjetOp*)it_f) )
+00110                         {
+00111                                 _Facts.erase( it_f );
+00112                                 tmp->release();
+00113                                 return;
+00114                         }
+00115                         it_f++;
+00116                 }
+00117                 tmp->release();
+00118         }
+00119 
+00120         void CFirstOrderAssert::addClause(CClause *clause, std::vector<sint32> &posvars) 
+00121         {
+00122                 _Clauses.push_back( clause );
+00123                 _PosVars.push_back(std::vector<sint32>());
+00124                 
+00125                 std::vector<sint32>::iterator it_pos = posvars.begin();
+00126                 while ( it_pos != posvars.end() )
+00127                 {
+00128                         _PosVars[ _Clauses.size() -1 ].push_back( *it_pos );
+00129                         it_pos++;
+00130                 }
+00131         }
+00132 
+00133         const NLAIC::IBasicType *CFirstOrderAssert::clone() const
+00134         {
+00135                 CFirstOrderAssert *clone = new CFirstOrderAssert( *this );              
+00136                 return (NLAIC::IBasicInterface *) clone;
+00137         }
+00138 
+00139         const NLAIC::IBasicType *CFirstOrderAssert::newInstance() const
+00140         {
+00141                 return clone();
+00142         }
+00143                 
+00144         void CFirstOrderAssert::save(NLMISC::IStream &os)
+00145         {
+00146         }
+00147 
+00148         void CFirstOrderAssert::load(NLMISC::IStream &is)
+00149         {
+00150         }
+00151 
+00152         void CFirstOrderAssert::getDebugString(std::string &text) const
+00153         {
+00154                 std::string buf;
+00155                 getName().getDebugString(buf);
+00156                 text += NLAIC::stringGetBuild("<CFirstOrderAssert> %s", buf.c_str());
+00157         }
+00158 
+00159         bool CFirstOrderAssert::isEqual(const CFirstOrderAssert &a) const
+00160         {
+00161                 return ( getName() == a.getName() );
+00162         }
+00163 
+00164         const IObjectIA::CProcessResult &CFirstOrderAssert::run()
+00165         {
+00166                 return IObjectIA::ProcessRun;
+00167         }
+00168 
+00169         bool CFirstOrderAssert::isEqual(const IBasicObjectIA &a) const
+00170         {
+00171                 return false;
+00172         }
+00173 
+00174         bool CFirstOrderAssert::isTrue() const
+00175         {
+00176                 return false;
+00177         }
+00178 
+00179         void CFirstOrderAssert::addInput(CClause *clause, std::vector<sint32> &posvars)
+00180         {
+00181                 _Clauses.push_back( clause );
+00182                 _PosVarsInputs.push_back( std::vector<sint32>() );
+00183                 
+00184                 std::vector<sint32>::iterator it_pos = posvars.begin();
+00185                 while ( it_pos != posvars.end() )
+00186                 {
+00187                         _PosVarsInputs[_Inputs.size() - 1].push_back( *it_pos );
+00188                         it_pos++;
+00189                 }
+00190         }
+00191 
+00192         const std::vector<CClause *> &CFirstOrderAssert::getClauses()
+00193         {
+00194                 return _Clauses;
+00195         }
+00196 
+00197         const NLAIC::CIdentType &CFirstOrderAssert::getType() const
+00198         {
+00199                 return IdFirstOrderAssert;
+00200         }
+00201 
+00202         void CFirstOrderAssert::init(IObjectIA *params)
+00203         {
+00204                 ((IBaseGroupType *)params)->popFront();
+00205                 
+00206                 _NbVars = (sint32) ( (DigitalType *) ((IBaseGroupType *)params)->popFront() )->getValue();
+00207         }
+00208 
+00209         sint32 CFirstOrderAssert::nbVars() const
+00210         {
+00211                 return _NbVars;
+00212         }
+00213 
+00214         void CFirstOrderAssert::backward(CValueSet *vs, std::list<CValueSet *> &bindings)
+00215         {
+00216                 /*              std::list<CValueSet *> *facts = new std::list<CValueSet *>;
+00217         
+00218                 CFactPattern *tmp_fp = new CFactPattern(*vs);
+00219                 tmp_fp->setAssert( this );
+00220 
+00221                 std::list<CClause *>::iterator it_cl = _Inputs.begin();
+00222                 while ( it_cl != _Inputs.end() )
+00223                 {
+00224                         CVarSet *l = ( (CRule *) *it_cl )->backward( tmp_fp );
+00225                         if ( l )
+00226                         {
+00227                                 char buf[1024 * 2];
+00228                                 l->getDebugString( buf );
+00229                                 bindings.pushBack( l );
+00230                         }
+00231                         it_cl++;
+00232                 }*/
+00233         }
+00234 
+00235         std::list<CFact *> *CFirstOrderAssert::backward(CFact *fact)
+00236         {
+00237                 // Recherche dans l'assertion...
+00238                 std::list<CFact *> *result = new std::list<CFact *>;
+00239                 CValueSet *liaison;
+00240 /*
+00241                 CConstIteratorContener it_f = _Facts.getConstIterator();
+00242                 while( !it_f.isInEnd() )
+00243                 {
+00244                         if ( *f == *(CFact *)((const IObjetOp*)it_f) )
+00245                         {
+00246                                 _Facts.erase( it_f );
+00247                                 tmp->release();
+00248                                 return;
+00249                         }
+00250                         it_f++;
+00251                 }
+00252 */
+00253 
+00254                 CConstIteratorContener it_l = _Facts.getConstIterator();
+00255                 while ( !it_l.isInEnd() )
+00256                 {
+00257 #ifdef NL_DEBUG
+00258                         std::string buffer;
+00259 
+00260                         ((CValueSet *)((const IObjetOp*)it_l))->getDebugString(buffer);
+00261                         std::string buffer2;
+00262                         fact->getDebugString(buffer2);
+00263 #endif
+00264 
+00265                         liaison = ((CValueSet *)((const IObjetOp*)it_l))->unify( (CValueSet *) fact );
+00266                         if ( liaison )
+00267                         {
+00268                                 if ( liaison->undefined() == 0 )
+00269                                 {
+00270                                         result->push_back( (CFact *) ((CValueSet *)((const IObjetOp*)it_l))->clone());
+00271                                 }
+00272                                 liaison->release();
+00273                         }
+00274                         it_l++;
+00275                 }
+00276 
+00277 
+00278                 // Et dans les règles dont la partie conclusion infèrent des faits de cette assertion
+00279                 std::list<CFact *> param;
+00280                 param.push_back( fact );
+00281                 std::vector<IBaseOperator *>::iterator it_i = _Inputs.begin();
+00282                 while ( it_i != _Inputs.end() )
+00283                 {
+00284                         ((CFirstOrderOperator *)(*it_i))->backward( param );
+00285                         it_i++;
+00286                 }
+00287 
+00288                 return result;
+00289         }
+00290 
+00291         std::list<CFact *> *CFirstOrderAssert::getFacts() const
+00292         {
+00293                 std::list<CFact *> *result = new std::list<CFact *>;
+00294                 CConstIteratorContener it_f = _Facts.getConstIterator();
+00295                 while ( !it_f.isInEnd() )
+00296                 {
+00297                         CFact *tmp = new CFact( (IBaseAssert *) this, ((CValueSet *)((const IObjetOp*)it_f)) );
+00298                         result->push_back( tmp );
+00299                         it_f++;
+00300                 }
+00301                 return result;
+00302         }
+00303 }
+00304 
+
fo_assert.cpp
