nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 #include "nel/ai/fuzzy/fuzzyset.h"
+00026 
+00027 namespace NLAIFUZZY
+00028 {
+00029         
+00030         void IFuzzySet::addFact(double value)
+00031         {
+00032                 _Facts.push_back( value );
+00033         }
+00034 
+00035         double IFuzzySet::agregate()
+00036         {
+00037                 if ( _Facts.size() )
+00038                 {
+00039                         // min
+00040                         double min = 1;
+00041                         while ( _Facts.size() )
+00042                         {
+00043                                 if ( _Facts.front() < min )
+00044                                         min = _Facts.front();
+00045                                 _Facts.pop_front();
+00046                         }
+00047                         _Value = min;
+00048                         return min;
+00049                 }
+00050                 else 
+00051                 {       
+00052                         _Value = 0.0;
+00053                         return 0.0;
+00054                 }
+00055         }
+00056 
+00057         double IFuzzySet::getValue()
+00058         {
+00059                 return _Value;
+00060         }
+00061 
+00062         CFuzzyInterval::CFuzzyInterval(char *name,double min, double max) : IFuzzySet(name)
+00063         {
+00064                 _Min = min;
+00065                 _Max = max;
+00066         }
+00067 
+00068         CFuzzyInterval::CFuzzyInterval(const CFuzzyInterval &cp) : IFuzzySet(cp._Name)
+00069         {
+00070                 _Min = cp._Min;
+00071                 _Max = cp._Max;
+00072         }
+00073 
+00074         void CFuzzyInterval::init(NLAIAGENT::IObjectIA *params)
+00075         {
+00076                 if ( ((NLAIAGENT::IBaseGroupType *)params)->size() != 3 ) 
+00077                 {
+00078                 //      throw Exc::
+00079                 }
+00080                 NLAIAGENT::IObjectIA  * arg = (NLAIAGENT::IObjectIA  *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00081                 _Min = (double) ((NLAIAGENT::DDigitalType *) arg )->getValue();
+00082                 arg->release();
+00083                 arg = (NLAIAGENT::IObjectIA  *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00084                 _Max = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00085                 arg->release();
+00086         }
+00087 
+00088         double CFuzzyInterval::membership(double val)
+00089         {
+00090                 if ( val >= _Min && val <= _Max )
+00091                         return 1.0;
+00092                 else
+00093                         return 0.0;
+00094         }
+00095 
+00096         bool CFuzzyInterval::isIn(double val)
+00097         {
+00098                 if ( val >= _Min && val <= _Max )
+00099                         return true;
+00100                 else
+00101                         return false;
+00102         }
+00103 
+00104         double CFuzzyInterval::surface()
+00105         {
+00106                 return ( _Max - _Min );
+00107         }
+00108 
+00109         double CFuzzyInterval::center()
+00110         {
+00111                 return ( _Min + _Max ) /2;
+00112         }
+00113 
+00114 
+00115         const NLAIC::IBasicType *CFuzzyInterval::clone() const 
+00116         {
+00117                 CFuzzyInterval *clone = new CFuzzyInterval( *this );
+00118                 return clone;
+00119         }
+00120 
+00121         const NLAIC::IBasicType *CFuzzyInterval::newInstance() const
+00122         {
+00123                 NLAIC::IBasicType *instance = new CFuzzyInterval( *this );
+00124 
+00125                 return instance;
+00126         }
+00127 
+00128         const NLAIC::CIdentType &CFuzzyInterval::getType() const
+00129         {
+00130                 return IdFuzzyInterval;
+00131         }
+00132 
+00133         void CFuzzyInterval::save(NLMISC::IStream &os)
+00134         {
+00135                 IFuzzySet::save(os);
+00136                 os.serial( (double &) _Min );
+00137                 os.serial( (double &) _Max );
+00138         }
+00139 
+00140         void CFuzzyInterval::load(NLMISC::IStream &is)
+00141         {
+00142         }
+00143 
+00144         void CFuzzyInterval::getDebugString(std::string &txt) const
+00145         {
+00146                 txt += NLAIC::stringGetBuild("%s [%f , %f]", _Name, _Min, _Max);
+00147         }
+00148 
+00149         bool CFuzzyInterval::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00150         {
+00151                 return ( ((CFuzzyInterval &)a)._Min == _Min && ((CFuzzyInterval &)a)._Max == _Max );
+00152         }
+00153         
+00154         const NLAIAGENT::IObjectIA::CProcessResult &CFuzzyInterval::run()
+00155         {
+00156                 return NLAIAGENT::IObjectIA::ProcessRun;
+00157         }
+00158 
+00161 
+00162 
+00163         CRightFuzzySet::CRightFuzzySet(char *name, double x1,double x2,double x3)  : IFuzzySet(name)
+00164         {
+00165                 _X1 = x1;
+00166                 _X2 = x2;
+00167                 _X3 = x3; 
+00168         }
+00169 
+00170         CRightFuzzySet::CRightFuzzySet(const CRightFuzzySet &cp) : IFuzzySet(cp._Name)
+00171         {
+00172                 _X1 = cp._X1;
+00173                 _X2 = cp._X2;
+00174                 _X3 = cp._X3;
+00175         }
+00176 
+00177         void CRightFuzzySet::init(NLAIAGENT::IObjectIA *params)
+00178         {
+00179                 if ( ((NLAIAGENT::IBaseGroupType *)params)->size() != 3 ) 
+00180                 {
+00181                 //      throw Exc::
+00182                 }
+00183                 NLAIAGENT::IObjectIA *arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00184                 _X1 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00185                 arg->release();
+00186                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00187                 _X2 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00188                 arg->release();
+00189                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00190                 _X3 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00191                 arg->release();
+00192         }
+00193 
+00194 
+00195         double CRightFuzzySet::membership(double val)
+00196         {
+00197                 if ( val >= _X2 && val <= _X3 )
+00198                         return 1.0;
+00199 
+00200                 if ( val > _X1 && val < _X2 ) 
+00201                 {
+00202                         return ( ( val - _X1 ) / ( _X2 - _X1 ) );
+00203                 }
+00204 
+00205                 return 0.0;
+00206         }
+00207 
+00208         bool CRightFuzzySet::isIn(double val)
+00209         {
+00210                 return ( val >= _X1 && val <= _X3 );
+00211         }
+00212 
+00213         double CRightFuzzySet::surface()
+00214         {
+00215                 return (_X2 - _X1) /2 + (_X3 - _X2);
+00216         }
+00217         
+00218         double CRightFuzzySet::center()
+00219         {
+00220                 return ( ( (_X1 + _X2) /4 + (_X2 + _X3) /2 ) /1.5);
+00221         }
+00222 
+00223         const NLAIC::IBasicType *CRightFuzzySet::clone() const
+00224         { 
+00225                 CRightFuzzySet *clone = new CRightFuzzySet( *this );
+00226                 return clone;
+00227         }
+00228         const NLAIC::IBasicType *CRightFuzzySet::newInstance() const
+00229         {
+00230                 NLAIC::IBasicType *instance = new CRightFuzzySet( *this );
+00231                 return instance;
+00232         }
+00233 
+00234         const NLAIC::CIdentType &CRightFuzzySet::getType() const
+00235         {
+00236                 return IdRightFuzzySet;
+00237         }
+00238 
+00239         void CRightFuzzySet::save(NLMISC::IStream &os)
+00240         {
+00241                 IFuzzySet::save(os);
+00242                 os.serial( (double &) _X1 );
+00243                 os.serial( (double &) _X2 );
+00244                 os.serial( (double &) _X3);
+00245         }
+00246 
+00247         void CRightFuzzySet::load(NLMISC::IStream &is)
+00248         {
+00249         }
+00250 
+00251         void CRightFuzzySet::getDebugString(std::string &txt) const
+00252         {
+00253                 txt += NLAIC::stringGetBuild("CRightFuzzySet %s [%f , %f , %f]", _Name, _X1, _X2, _X3);
+00254         }
+00255         
+00256         bool CRightFuzzySet::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00257         {
+00258                 return ( ((CRightFuzzySet &)a)._X1 == _X1 && 
+00259                                  ((CRightFuzzySet &)a)._X2 == _X2 && 
+00260                                  ((CRightFuzzySet &)a)._X3 == _X3 );
+00261         }
+00262 
+00263         const NLAIAGENT::IObjectIA::CProcessResult &CRightFuzzySet::run()
+00264         {
+00265                 return NLAIAGENT::IObjectIA::ProcessRun;
+00266         }
+00267 
+00268 
+00269 
+00270         NLAIAGENT::tQueue IFuzzySet::isMember(const NLAIAGENT::IVarName *className,const NLAIAGENT::IVarName *funcName,const NLAIAGENT::IObjectIA &params) const
+00271         {
+00272 
+00273 #ifdef NL_DEBUG 
+00274         std::string nameP;
+00275         std::string nameM;
+00276         funcName->getDebugString(nameM);
+00277         params.getDebugString(nameP);
+00278 
+00279         const char *dbg_class_name = (const char *) getType();
+00280 #endif
+00281                 NLAIAGENT::tQueue r;
+00282                 if(className == NULL)
+00283                 {
+00284                         if( (*funcName) == NLAIAGENT::CStringVarName( "Constructor" ) )
+00285                         {                                       
+00286                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CTriangleFuzzySet::IdTriangleFuzzySet ) );
+00287                                 r.push( NLAIAGENT::CIdMethod( 0 + IObjectIA::getMethodIndexSize(), 0.0, NULL, c) );
+00288                         }
+00289 
+00290                         if( (*funcName) == NLAIAGENT::CStringVarName( "Membership" ) )
+00291                         {                                       
+00292                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( NLAIAGENT::DigitalType::IdDigitalType ) );
+00293                                 r.push( NLAIAGENT::CIdMethod( 1 + IObjectIA::getMethodIndexSize(), 0.0, NULL, c) );
+00294                         }
+00295 
+00296                 }
+00297 
+00298                 if ( r.empty() )
+00299                         return IObjectIA::isMember(className, funcName, params);
+00300                 else
+00301                         return r;
+00302         }
+00303 
+00304         NLAIAGENT::IObjectIA::CProcessResult IFuzzySet::runMethodeMember(sint32 index, NLAIAGENT::IObjectIA *p)
+00305         {
+00306                 switch(index - IObjectIA::getMethodIndexSize() )
+00307                 {
+00308                 case 0:
+00309                         {                                       
+00310                                 init(p);
+00311                         }
+00312                         break;
+00313 
+00314                 case 1:
+00315                         {
+00316                                 NLAIAGENT::IObjectIA::CProcessResult r;
+00317                                 const NLAIAGENT::IObjectIA *obj = ( (NLAIAGENT::IBaseGroupType *) p )->get();
+00318                                 float val = float(( (NLAIAGENT::DDigitalType *) obj)->getNumber());
+00319                                 r.Result = new NLAIAGENT::DDigitalType( membership( val ) );
+00320                                 return r;
+00321                         }
+00322                 }
+00323 
+00324                 return NLAIAGENT::IObjectIA::CProcessResult();
+00325         }
+00326 
+00327 
+00328 
+00329 /*
+00330         const NLAIC::CIdentType CompositeiFuzzySet::idCompositeiFuzzySet = NLAIC::CIdentType("CompositeiFuzzySet",NLAIC::CSelfClassCFactory(CompositeiFuzzySet()),
+00331                 NLAIC::CTypeOfObject::tObject,
+00332                 NLAIC::CTypeOfOperator::opAdd |
+00333                 NLAIC::CTypeOfOperator::opSub |
+00334                 NLAIC::CTypeOfOperator::opEq );
+00335         
+00336         CompositeiFuzzySet::CompositeiFuzzySet()
+00337         {
+00338         }
+00339         
+00340         CompositeiFuzzySet::CompositeiFuzzySet(const CompositeiFuzzySet &cp)
+00341         {
+00342                 list<IFuzzySet *>::const_iterator it_f = cp._iFuzzySets.begin();
+00343                 while ( it_f  != cp._iFuzzySets.end() )
+00344                 {
+00345                         _iFuzzySets.push_back( (IFuzzySet *) (*it_f)->clone() );
+00346                         it_f++;
+00347                 }
+00348         }
+00349 
+00350         void CompositeiFuzzySet::addiFuzzySet(IFuzzySet *f)
+00351         {
+00352                 _iFuzzySets.push_back(f);
+00353         }
+00354 
+00355         double CompositeiFuzzySet::membership(double val)
+00356         {
+00357                 list<IFuzzySet *>::iterator it_f = _iFuzzySets.begin();
+00358                 while ( it_f  != _iFuzzySets.end() )
+00359                 {
+00360                         if ( (*it_f)->isIn( val ) )
+00361                                 return (*it_f)->membership( val );
+00362                         it_f++;
+00363                 }
+00364                 return 0.0;
+00365         }
+00366 
+00367         bool CompositeiFuzzySet::isIn(double val )
+00368         {
+00369                 list<IFuzzySet *>::iterator it_f = _iFuzzySets.begin();
+00370                 while ( it_f  != _iFuzzySets.end() )
+00371                 {
+00372                         if ( (*it_f)->isIn( val ) )
+00373                                 return true;
+00374                         it_f++;
+00375                 }
+00376                 return false;
+00377         }
+00378 
+00379         double CompositeiFuzzySet::center()
+00380         {
+00381                 // TODO
+00382                 return 0.0;
+00383         }
+00384 
+00385         bool CompositeiFuzzySet::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00386         {
+00387                 return false;
+00388         }
+00389 
+00390         const NLAIC::IBasicType *CompositeiFuzzySet::clone() const 
+00391         {
+00392                 return new CompositeiFuzzySet( *this );
+00393         }
+00394 
+00395         const NLAIC::IBasicType *CompositeiFuzzySet::newInstance() const
+00396         {
+00397                 return new CompositeiFuzzySet( *this ); 
+00398         }
+00399 
+00400         const NLAIC::CIdentType &CompositeiFuzzySet::getType() const
+00401         {
+00402                 return idCompositeiFuzzySet;
+00403         }
+00404 
+00405         void CompositeiFuzzySet::save(NLMISC::IStream &os)
+00406         {
+00407         }
+00408 
+00409         void CompositeiFuzzySet::load(NLMISC::IStream &is)
+00410         {
+00411         }
+00412 
+00413         void CompositeiFuzzySet::getDebugString(char *txt) const
+00414         {
+00415                 sprintf(txt,"CompositeiFuzzySet");
+00416         }
+00417 
+00418         const TProcessStatement &CompositeiFuzzySet::run()
+00419         {
+00420                 return NLAIAGENT::IObjectIA::AgentIdle;
+00421         }
+00422 */
+00425 
+00426 
+00427 
+00428         CTriangleFuzzySet::CTriangleFuzzySet(char *name, double x1,double x2,double x3)  : IFuzzySet(name)
+00429         {
+00430                 _X1 = x1;
+00431                 _X2 = x2;
+00432                 _X3 = x3;
+00433         }
+00434 
+00435         CTriangleFuzzySet::CTriangleFuzzySet(const CTriangleFuzzySet &cp) : IFuzzySet(cp._Name)
+00436         {
+00437                 _X1 = cp._X1;
+00438                 _X2 = cp._X2;
+00439                 _X3 = cp._X3;
+00440         }
+00441 
+00442         void CTriangleFuzzySet::init(NLAIAGENT::IObjectIA *params)
+00443         {
+00444 #ifdef NL_DEBUG
+00445                 std::string buf;
+00446                 params->getDebugString(buf);
+00447 #endif
+00448 
+00449                 sint32 i = ((NLAIAGENT::IBaseGroupType *)params)->size();
+00450                 if ( i != 3 ) 
+00451                 {
+00452                 //      throw Exc::
+00453                 }
+00454                 NLAIAGENT::IObjectIA *arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00455                 _X1 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00456                 arg->release();
+00457 
+00458                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00459                 _X2 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00460                 arg->release();
+00461 
+00462                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00463                 _X3 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00464                 arg->release();
+00465         }
+00466 
+00467 
+00468         double CTriangleFuzzySet::membership(double val)
+00469         {
+00470                 if ( val > _X1 && val < _X2 )
+00471                 {
+00472                         return ( ( val - _X1 ) / ( _X2 - _X1 ) );
+00473                 }
+00474 
+00475                 if ( val > _X2 && val < _X3 )
+00476                 {
+00477                         return ( ( val - _X2 ) / ( _X3 - _X2 ) );
+00478                 }
+00479 
+00480                 return 0.0;
+00481         }
+00482 
+00483         bool CTriangleFuzzySet::isIn(double val)
+00484         {
+00485                 return ( val > _X1 && val < _X2 );
+00486         }
+00487 
+00488         double CTriangleFuzzySet::surface()
+00489         {
+00490                 return (_X3 - _X2) /2;
+00491         }
+00492 
+00493         double CTriangleFuzzySet::center()
+00494         {
+00495                 return ( ( (_X1 + _X2) /2 * (_X2 - _X1) ) +
+00496                                  ( (_X2 + _X3) /2 * (_X3 - _X2) ) ) 
+00497                                  / (_X3 - _X1);
+00498         }
+00499 
+00500         const NLAIC::IBasicType *CTriangleFuzzySet::clone() const
+00501         {
+00502                 CTriangleFuzzySet *clone = new CTriangleFuzzySet( *this );
+00503                 return clone;
+00504         }
+00505         const NLAIC::IBasicType *CTriangleFuzzySet::newInstance() const
+00506         {
+00507                 NLAIC::IBasicType *instance = new CTriangleFuzzySet( *this );
+00508                 return instance;
+00509         }
+00510 
+00511         const NLAIC::CIdentType &CTriangleFuzzySet::getType() const
+00512         {
+00513                 return IdTriangleFuzzySet;
+00514         }
+00515         void CTriangleFuzzySet::save(NLMISC::IStream &os)
+00516         {
+00517                 IFuzzySet::save(os);
+00518                 os.serial( (double &) _X1 );
+00519                 os.serial( (double &) _X2 );
+00520                 os.serial( (double &) _X3 );
+00521         }
+00522 
+00523         void CTriangleFuzzySet::load(NLMISC::IStream &is)
+00524         {
+00525                 is.serial( _X1 );
+00526                 is.serial( _X2 );
+00527                 is.serial( _X3 );
+00528         }
+00529 
+00530         void CTriangleFuzzySet::getDebugString(std::string &txt) const
+00531         {
+00532                 txt += NLAIC::stringGetBuild("CTriangleFuzzySet %s [%f , %f , %f]", _Name, _X1, _X2, _X3);
+00533         }
+00534         
+00535         bool CTriangleFuzzySet::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00536         {
+00537                 return ( ((CTriangleFuzzySet &)a)._X1 == _X1 && ((CTriangleFuzzySet &)a)._X2 == _X2 && ((CTriangleFuzzySet &)a)._X3 == _X3 );
+00538         }
+00539 
+00540         const NLAIAGENT::IObjectIA::CProcessResult &CTriangleFuzzySet::run()
+00541         {
+00542                 return NLAIAGENT::IObjectIA::ProcessRun;
+00543         }
+00544 
+00547         
+00548         
+00549         CLeftFuzzySet::CLeftFuzzySet(char *name, double p1,double p2,double p3) : IFuzzySet(name)
+00550         {
+00551                 _X1 = p1;
+00552                 _X2 = p2;
+00553                 _X3 = p3;
+00554         }
+00555 
+00556         CLeftFuzzySet::CLeftFuzzySet( const CLeftFuzzySet &cp ) : IFuzzySet(cp._Name)
+00557         {
+00558                 _X1 = cp._X1;
+00559                 _X2 = cp._X2;
+00560                 _X3 = cp._X3;
+00561         }
+00562 
+00563         void CLeftFuzzySet::init(NLAIAGENT::IObjectIA *params)
+00564         {
+00565                 if ( ((NLAIAGENT::IBaseGroupType *)params)->size() != 3 ) 
+00566                 {
+00567                 //      throw Exc::
+00568                 }
+00569                 
+00570                 NLAIAGENT::IObjectIA *arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00571                 _X1 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00572                 arg->release();
+00573 
+00574                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00575                 _X2 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00576                 arg->release();
+00577 
+00578                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00579                 _X3 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00580                 arg->release();
+00581         }
+00582 
+00583         CLeftFuzzySet::~CLeftFuzzySet()
+00584         {
+00585         }
+00586 
+00587         double CLeftFuzzySet::membership(double val)
+00588         {
+00589                 if ( val >= _X1 && val <= _X2 )
+00590                         return 1.0;
+00591 
+00592                 if ( val > _X2 && val < _X3 )
+00593                 {
+00594                         return ( ( val - _X2 ) / ( _X3 - _X2 ) );
+00595                 }
+00596 
+00597                 return 0.0;
+00598         }
+00599 
+00600         bool CLeftFuzzySet::isIn(double val)
+00601         {
+00602                 return ( val >= _X1 && val <= _X3 );
+00603         }
+00604 
+00605         double CLeftFuzzySet::surface()
+00606         {
+00607                 return (_X2 - _X1) + (_X3 - _X2) /2;
+00608         }
+00609 
+00610         double CLeftFuzzySet::center()
+00611         {
+00612                 return ( ( (_X1 + _X2) /2 + (_X2 + _X3) /4 ) /1.5);
+00613         }
+00614 
+00615         const NLAIC::IBasicType *CLeftFuzzySet::clone() const
+00616         { 
+00617                 CLeftFuzzySet *clone = new CLeftFuzzySet( *this );
+00618                 return clone;
+00619         }
+00620         const NLAIC::IBasicType *CLeftFuzzySet::newInstance() const
+00621         {
+00622                 NLAIC::IBasicType *instance = new CLeftFuzzySet( *this );
+00623                 return instance;
+00624         }
+00625 
+00626         const NLAIC::CIdentType &CLeftFuzzySet::getType() const
+00627         {
+00628                 return IdLeftFuzzySet;
+00629         }
+00630 
+00631         void CLeftFuzzySet::save(NLMISC::IStream &os)
+00632         {
+00633                 IFuzzySet::save(os);
+00634                 os.serial( (double &) _X1 );
+00635                 os.serial( (double &) _X2 );
+00636                 os.serial( (double &) _X3 );
+00637         }
+00638 
+00639         void CLeftFuzzySet::load(NLMISC::IStream &is)
+00640         {
+00641         }
+00642 
+00643         void CLeftFuzzySet::getDebugString(std::string &txt) const
+00644         {
+00645                 txt += NLAIC::stringGetBuild("CLeftFuzzySet %s [%f , %f , %f]", _Name, _X1, _X2, _X3);
+00646         }
+00647         
+00648         bool CLeftFuzzySet::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00649         {
+00650                 return ( ((CLeftFuzzySet &)a)._X1 == _X1 && ((CLeftFuzzySet &)a)._X2 == _X2 && ((CLeftFuzzySet &)a)._X3 == _X3 );
+00651         }
+00652 
+00653         const NLAIAGENT::IObjectIA::CProcessResult &CLeftFuzzySet::run()
+00654         {
+00655                 return NLAIAGENT::IObjectIA::ProcessRun;
+00656         }
+00657 
+00660 
+00661 
+00662 
+00663         CTrapezeFuzzySet::CTrapezeFuzzySet(char *name, double p1,double p2,double p3, double p4) : IFuzzySet(name)
+00664         {
+00665                 _X1 = p1;
+00666                 _X2 = p2;
+00667                 _X3 = p3;
+00668                 _X4 = p4;
+00669         }
+00670  
+00671         CTrapezeFuzzySet::CTrapezeFuzzySet(const CTrapezeFuzzySet &cp) : IFuzzySet(cp._Name)
+00672         {
+00673                 _X1 = cp._X1;
+00674                 _X2 = cp._X2;
+00675                 _X3 = cp._X3;
+00676                 _X4 = cp._X4;
+00677         }
+00678 
+00679         void CTrapezeFuzzySet::init(NLAIAGENT::IObjectIA *params)
+00680         {
+00681                 if ( ((NLAIAGENT::IBaseGroupType *)params)->size() != 3 ) 
+00682                 {
+00683                 //      throw Exc::
+00684                 }
+00685                 NLAIAGENT::IObjectIA *arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00686                 _X1 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00687                 arg->release();
+00688                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00689                 _X2 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00690                 arg->release();
+00691                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00692                 _X3 = (double) ((NLAIAGENT::DDigitalType *) arg)->getValue();
+00693                 arg->release();
+00694                 arg = (NLAIAGENT::IObjectIA *) ((NLAIAGENT::IBaseGroupType *)params)->popFront();
+00695                 _X4 = (double) ((NLAIAGENT::DDigitalType *)arg)->getValue();
+00696                 arg->release();
+00697 
+00698         }
+00699 
+00700         CTrapezeFuzzySet::~CTrapezeFuzzySet()
+00701         {
+00702         }
+00703 
+00704         double CTrapezeFuzzySet::membership(double val)
+00705         {
+00706                 if ( val >= _X2 && val <= _X3 )
+00707                         return 1.0;
+00708 
+00709                 if ( val > _X1 && val < _X2 )
+00710                 {
+00711                         return ( ( val - _X1 ) / ( _X2 - _X1 ) );
+00712                 }
+00713 
+00714                 if ( val > _X3 && val < _X2 )
+00715                 {
+00716                         return ( ( val - _X3 ) / ( _X4 - _X3 ) );
+00717                 }
+00718 
+00719                 return 0.0;
+00720         }
+00721 
+00722         bool CTrapezeFuzzySet::isIn(double val)
+00723         {
+00724                 return ( val > _X1 && val < _X4 );
+00725         }
+00726 
+00727         double CTrapezeFuzzySet::surface()
+00728         {
+00729                 return (_X2 - _X1) /2 + (_X3 - _X2) + (_X4 - _X3) / 2;
+00730         }
+00731 
+00732         double CTrapezeFuzzySet::center()
+00733         {
+00734                 return (_X1 + _X2) /2 + (_X2 + _X3) /4;
+00735         }
+00736 
+00737         const NLAIC::IBasicType *CTrapezeFuzzySet::clone() const
+00738         { 
+00739                 CTrapezeFuzzySet *clone = new CTrapezeFuzzySet( *this );
+00740                 return clone;
+00741         }
+00742         const NLAIC::IBasicType *CTrapezeFuzzySet::newInstance() const
+00743         {
+00744                 NLAIC::IBasicType *instance = new CTrapezeFuzzySet( *this );
+00745                 return instance;
+00746         }
+00747 
+00748         const NLAIC::CIdentType &CTrapezeFuzzySet::getType() const
+00749         {
+00750                 return IdTrapezeFuzzySet;
+00751         }
+00752 
+00753         void CTrapezeFuzzySet::save(NLMISC::IStream &os)
+00754         {
+00755                 IFuzzySet::save(os);
+00756                 os.serial( (double &) _X1 );
+00757                 os.serial( (double &) _X2 );
+00758                 os.serial( (double &) _X3 );
+00759                 os.serial( (double &) _X4 );
+00760         }
+00761 
+00762         void CTrapezeFuzzySet::load(NLMISC::IStream &is)
+00763         {
+00764         }
+00765 
+00766         void CTrapezeFuzzySet::getDebugString(std::string &txt) const
+00767         {
+00768                 txt += NLAIC::stringGetBuild("CTrapezeFuzzySet %s [%f , %f , %f , %f]", _Name, _X1, _X2, _X3, _X4);
+00769         }
+00770         
+00771         bool CTrapezeFuzzySet::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+00772         {
+00773                 return ( ((CTrapezeFuzzySet &)a)._X1 == _X1 && 
+00774                                  ((CTrapezeFuzzySet &)a)._X2 == _X2 && 
+00775                                  ((CTrapezeFuzzySet &)a)._X3 == _X3 &&
+00776                                  ((CTrapezeFuzzySet &)a)._X4 == _X4 );
+00777         }
+00778 
+00779         const NLAIAGENT::IObjectIA::CProcessResult &CTrapezeFuzzySet::run()
+00780         {
+00781                 return NLAIAGENT::IObjectIA::ProcessRun;
+00782         }
+00783 }
+
fuzzyset.cpp
