#include <mhics.h>
Nevrax France
Definition at line 122 of file mhics.h.
Public Member Functions | |
| void | addActionCS (const CActionClassifiers &action) |
| Add a new action in the net. | |
| void | addVirtualActionCS (const CActionClassifiers &action) |
| CMHiCSbase () | |
| void | dbgPrintClassifierPriorityInFile (std::string fileName) const |
| void | dividePriorityByTheMinPriorityPartInAMotivation (TMotivation motivationName) |
| TAction | getActionPart (TMotivation motivationName, TClassifierNumber classifierNumber) const |
| void | getDebugString (std::string &t) const |
| Chaine de debug. | |
| CClassifierPriority | getPriorityPart (TMotivation motivationName, TClassifierNumber classifierNumber) const |
| bool | isAnAction (TAction behav) const |
| To now if a behav selected by a CS is an action (if not, it's a common CS). | |
| void | learningUpdatePriorityValueClassifierTime (TMotivation motivationName, TClassifierNumber classifierNumber, uint32 time) |
| void | learningUpdatePriorityValueTimeToSuccess (TMotivation motivationName, TClassifierNumber classifierNumber, uint32 timeToSuccess) |
| Update a priority value in learning mode. | |
| bool | loadClassifierFromFile (std::string fileName) |
| Load classifiers from a file. Return false if thereis a probleme. | |
| void | printDebugString () const |
| void | selectBehavior (TMotivation motivationName, const CCSPerception *psensorMap, std::multimap< CClassifierPriority, std::pair< TClassifierNumber, TTargetId > > &mapActivableCS) |
| void | setPriorityValue (TMotivation motivationName, TClassifierNumber classifierNumber, CClassifierPriority priority) |
| Set a new value for a classifier priority. | |
| virtual | ~CMHiCSbase () |
Data Fields | |
| CActionResources * | pActionResources |
Private Attributes | |
| std::set< TAction > | _ActionSet |
| std::map< TMotivation, CClassifierSystem > | _MotivationClassifierSystems |
| std::map< TAction, CClassifierSystem > | _VirtualActionClassifierSystems |
|
|
Definition at line 212 of file mhics.cpp. References pActionResources.
00213 {
00214 pActionResources = new CActionResources();
00215 }
|
|
|
Definition at line 217 of file mhics.cpp. References pActionResources.
00218 {
00219 delete pActionResources;
00220 }
|
|
|
Add a new action in the net.
Definition at line 249 of file mhics.cpp. References _ActionSet, NLAINIMAT::Action_VIRTUAL_ACTIONS, addVirtualActionCS(), NLAINIMAT::CActionClassifiers::getName(), and nlassert. Referenced by loadClassifierFromFile().
00250 {
00251 nlassert ( action.getName() < Action_VIRTUAL_ACTIONS);
00252 addVirtualActionCS(action);
00253 _ActionSet.insert(action.getName());
00254 }
|
|
|
Add a new virtual action in the net. A virtual action is an action without operator wich is also a motivation. Exemple : Figthing is a virtual action. It may satisfy the anger motivation and is a motivation for guive a sword slash. Definition at line 222 of file mhics.cpp. References _MotivationClassifierSystems, _VirtualActionClassifierSystems, NLAINIMAT::CClassifierSystem::addClassifierSystem(), NLAINIMAT::CActionClassifiers::getClassifiersByMotivationMap(), NLAINIMAT::CActionClassifiers::getClassifiersByVirtualActionMap(), NLAINIMAT::TAction, and NLAINIMAT::TMotivation. Referenced by addActionCS(), and loadClassifierFromFile().
00223 {
00224 const std::map<TMotivation, CClassifierSystem> *mapActionByMotivation = action.getClassifiersByMotivationMap();
00225 std::map<TMotivation, CClassifierSystem>::const_iterator ItMapActionByMotivation;
00226 for (ItMapActionByMotivation = mapActionByMotivation->begin(); ItMapActionByMotivation != mapActionByMotivation->end(); ItMapActionByMotivation++)
00227 {
00228 CClassifierSystem* pCS;
00229 TMotivation motivationName = (*ItMapActionByMotivation).first;
00230 const CClassifierSystem* pOtherCS = &((*ItMapActionByMotivation).second);
00231
00232 pCS = &(_MotivationClassifierSystems[motivationName]);
00233 pCS->addClassifierSystem(*pOtherCS);
00234 }
00235
00236 const std::map<TAction, CClassifierSystem> *mapActionByVirtualAction = action.getClassifiersByVirtualActionMap();
00237 std::map<TAction, CClassifierSystem>::const_iterator ItMapActionByVirtualAction;
00238 for (ItMapActionByVirtualAction = mapActionByVirtualAction->begin(); ItMapActionByVirtualAction != mapActionByVirtualAction->end(); ItMapActionByVirtualAction++)
00239 {
00240 CClassifierSystem* pCS;
00241 TAction virtualActionName = (*ItMapActionByVirtualAction).first;
00242 const CClassifierSystem* pOtherCS = &((*ItMapActionByVirtualAction).second);
00243
00244 pCS = &(_VirtualActionClassifierSystems[virtualActionName]);
00245 pCS->addClassifierSystem(*pOtherCS);
00246 }
00247 }
|
|
|
Definition at line 531 of file mhics.cpp. References _MotivationClassifierSystems, NLMISC::COFile::close(), NLMISC::CIFile::close(), NLAINIMAT::CClassifierPriority::getClassifierTimer(), NLAINIMAT::CClassifierPriority::getPriority(), getPriorityPart(), NLAINIMAT::CClassifierPriority::getPriorityTimer(), len, NLMISC::COFile::open(), NLMISC::CIFile::open(), NLMISC::COFile::serialBuffer(), NLAINIMAT::TMotivation, NLMISC::toString(), uint, and uint8.
00532 {
00533 int i;
00534 std::map<TMotivation, CClassifierSystem>::const_iterator itMotivationClassifierSystems;
00535 std::string nomDuFichier = "D:\\jgab\\doc\\IA\\_These\\gnuplot\\TFC\\";
00536 nomDuFichier += fileName;
00537
00538 NLMISC::CIFile baltazar;
00539 bool yaqqunauboutdufil = baltazar.open(nomDuFichier.c_str(), true);
00540 baltazar.close();
00541
00542 NLMISC::COFile melkior;
00543 std::string ohlabellephrase = "";
00544
00545 if (!yaqqunauboutdufil)
00546 {
00547 melkior.open(nomDuFichier.c_str(), false, true);
00548
00549 for(itMotivationClassifierSystems = _MotivationClassifierSystems.begin();
00550 itMotivationClassifierSystems != _MotivationClassifierSystems.end();
00551 itMotivationClassifierSystems++)
00552 {
00553 TMotivation laMotive = (*itMotivationClassifierSystems).first;
00554 for (i= 0; i< (*itMotivationClassifierSystems).second.getClassifierNumber(); i++)
00555 {
00556 ohlabellephrase += "MAX ";
00557 ohlabellephrase += NLAINIMAT::conversionMotivation.toString(laMotive);
00558 ohlabellephrase += " ";
00559 (*itMotivationClassifierSystems).second.getDebugString(i,ohlabellephrase);
00560 ohlabellephrase += ";T2S ";
00561 ohlabellephrase += NLAINIMAT::conversionMotivation.toString(laMotive);
00562 ohlabellephrase += " ";
00563 (*itMotivationClassifierSystems).second.getDebugString(i,ohlabellephrase);
00564 ohlabellephrase += ";ExT ";
00565 ohlabellephrase += NLAINIMAT::conversionMotivation.toString(laMotive);
00566 ohlabellephrase += " ";
00567 (*itMotivationClassifierSystems).second.getDebugString(i,ohlabellephrase);
00568 // ohlabellephrase += NLMISC::toString(i);
00569
00570 ohlabellephrase += ";";
00571 }
00572 }
00573 ohlabellephrase += "\n";
00574 }
00575 else
00576 {
00577 melkior.open(nomDuFichier.c_str(), true, true);
00578 }
00579
00580 for(itMotivationClassifierSystems = _MotivationClassifierSystems.begin();
00581 itMotivationClassifierSystems != _MotivationClassifierSystems.end();
00582 itMotivationClassifierSystems++)
00583 {
00584 TMotivation laMotive = (*itMotivationClassifierSystems).first;
00585 for (i= 0; i< (*itMotivationClassifierSystems).second.getClassifierNumber(); i++)
00586 {
00587 CClassifierPriority laSuperPrio = getPriorityPart(laMotive, i);
00588 ohlabellephrase += NLMISC::toString(laSuperPrio.getPriority());
00589 ohlabellephrase += ";";
00590 ohlabellephrase += NLMISC::toString(laSuperPrio.getPriorityTimer());
00591 ohlabellephrase += ";";
00592 ohlabellephrase += NLMISC::toString(laSuperPrio.getClassifierTimer());
00593 ohlabellephrase += ";";
00594 }
00595 }
00596 ohlabellephrase += "\n";
00597
00598
00599 uint8 *buf = (uint8 *)ohlabellephrase.c_str();
00600 uint len = ohlabellephrase.length();
00601 melkior.serialBuffer(buf,len);
00602 melkior.close();
00603 }
|
|
|
|
|
||||||||||||
|
Give the action part of a given Classifier.
Definition at line 285 of file mhics.cpp. References _MotivationClassifierSystems, NLAINIMAT::Action_DoNothing, nlassert, NLAINIMAT::TAction, and NLAINIMAT::TClassifierNumber. Referenced by NLAINIMAT::CMHiCSagent::motivationCompute().
00286 {
00287 if (classifierNumber == -1) return Action_DoNothing;
00288
00289 std::map<TMotivation, CClassifierSystem>::const_iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00290 nlassert(itMotivationClassifierSystems != _MotivationClassifierSystems.end());
00291 return (*itMotivationClassifierSystems).second.getActionPart(classifierNumber);
00292 }
|
|
|
Chaine de debug.
Definition at line 334 of file mhics.cpp. References _ActionSet, _MotivationClassifierSystems, _VirtualActionClassifierSystems, and t.
00335 {
00336 std::string ret = "\n---------------------------";
00337 std::map<TMotivation, CClassifierSystem>::const_iterator itMotivationClassifierSystems;
00338 for (itMotivationClassifierSystems = _MotivationClassifierSystems.begin(); itMotivationClassifierSystems != _MotivationClassifierSystems.end(); itMotivationClassifierSystems++)
00339 {
00340 ret += "\nMotivation : " + conversionMotivation.toString((*itMotivationClassifierSystems).first);
00341 (*itMotivationClassifierSystems).second.getDebugString(ret);
00342 }
00343 std::map<TAction, CClassifierSystem>::const_iterator itVirtualActionClassifierSystems;
00344 for (itVirtualActionClassifierSystems = _VirtualActionClassifierSystems.begin(); itVirtualActionClassifierSystems != _VirtualActionClassifierSystems.end(); itVirtualActionClassifierSystems++)
00345 {
00346 ret += "\nVirtual Action : " + conversionAction.toString((*itVirtualActionClassifierSystems).first);
00347 (*itVirtualActionClassifierSystems).second.getDebugString(ret);
00348 }
00349 ret += "\nACTIONS :\n";
00350 std::set<TAction>::const_iterator itActionSet;
00351 for (itActionSet = _ActionSet.begin(); itActionSet != _ActionSet.end(); itActionSet++)
00352 {
00353 ret += conversionAction.toString((*itActionSet)) + "\n";
00354 }
00355 t+=ret;
00356 }
|
|
||||||||||||
|
Definition at line 303 of file mhics.cpp. References _MotivationClassifierSystems, nlassert, and NLAINIMAT::TClassifierNumber. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(), and dbgPrintClassifierPriorityInFile().
00304 {
00305 if (classifierNumber == -1) return CClassifierPriority();
00306
00307 std::map<TMotivation, CClassifierSystem>::const_iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00308 nlassert(itMotivationClassifierSystems != _MotivationClassifierSystems.end());
00309 return (*itMotivationClassifierSystems).second.getPriorityPart(classifierNumber);
00310 }
|
|
|
To now if a behav selected by a CS is an action (if not, it's a common CS).
Definition at line 327 of file mhics.cpp. References _ActionSet.
00328 {
00329 std::set<TAction>::const_iterator itActionSet = _ActionSet.find(behav);
00330 return (itActionSet != _ActionSet.end());
00331 }
|
|
||||||||||||||||
|
Definition at line 634 of file mhics.cpp. References _MotivationClassifierSystems, nlassert, NLAINIMAT::CClassifierPriority::SetClassifierTimer(), NLAINIMAT::CClassifierPriority::setPriorityTimer(), NLAINIMAT::TClassifierNumber, and uint32. Referenced by NLAINIMAT::CMHiCSagent::learningComputation().
00635 {
00636 // Le but est de faire une moyenne sur les valeurs de fitness. Pour ça on fait une moyenne sur les 10 pas de temps précédents.
00637 std::map<TMotivation, CClassifierSystem>::iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00638 nlassert(itMotivationClassifierSystems != _MotivationClassifierSystems.end());
00639 uint32 oldTime = (*itMotivationClassifierSystems).second.getPriorityPart(classifierNumber).getClassifierTimer();
00640 uint32 newTime;
00641 if (oldTime == 0)
00642 {
00643 newTime = time;
00644 }
00645 else
00646 {
00647 if (oldTime > time)
00648 {
00649 newTime = (time + oldTime*3)/4;
00650 }
00651 else
00652 {
00653 newTime = (time*3 + oldTime)/4;
00654 }
00655 }
00656 CClassifierPriority newPrio;
00657 newPrio.setPriorityTimer((*itMotivationClassifierSystems).second.getPriorityPart(classifierNumber).getPriorityTimer());
00658 newPrio.SetClassifierTimer(newTime);
00659 // newPrio.SetClassifierTimer(time);
00660 (*itMotivationClassifierSystems).second.setPriorityPart(classifierNumber, newPrio);
00661 }
|
|
||||||||||||||||
|
Update a priority value in learning mode.
Definition at line 605 of file mhics.cpp. References _MotivationClassifierSystems, nlassert, NLAINIMAT::CClassifierPriority::SetClassifierTimer(), NLAINIMAT::CClassifierPriority::setPriorityTimer(), NLAINIMAT::TClassifierNumber, and uint32. Referenced by NLAINIMAT::CMHiCSagent::learningComputation().
00606 {
00607 // Le but est de faire une moyenne sur les valeurs de fitness. Pour ça on fait une moyenne sur les 4 pas de temps précédents.
00608 std::map<TMotivation, CClassifierSystem>::iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00609 nlassert(itMotivationClassifierSystems != _MotivationClassifierSystems.end());
00610 uint32 oldTime2Success = (*itMotivationClassifierSystems).second.getPriorityPart(classifierNumber).getPriorityTimer();
00611 uint32 newTime2Success;
00612 if (oldTime2Success == 0)
00613 {
00614 newTime2Success = timeToSuccess;
00615 }
00616 else
00617 {
00618 if (oldTime2Success > timeToSuccess)
00619 {
00620 newTime2Success = (timeToSuccess*3 + oldTime2Success)/4;
00621 }
00622 else
00623 {
00624 newTime2Success = (timeToSuccess + oldTime2Success*3)/4;
00625 }
00626 }
00627 // nlassert (newTime2Success != 0);
00628 CClassifierPriority newPrio;
00629 newPrio.setPriorityTimer(newTime2Success);
00630 // newPrio.setPriorityTimer(timeToSuccess);
00631 newPrio.SetClassifierTimer((*itMotivationClassifierSystems).second.getPriorityPart(classifierNumber).getClassifierTimer());
00632 (*itMotivationClassifierSystems).second.setPriorityPart(classifierNumber, newPrio);
00633 }
|
|
|
Load classifiers from a file. Return false if thereis a probleme.
Definition at line 391 of file mhics.cpp. References NLAINIMAT::Action_Unknown, NLAINIMAT::Action_VIRTUAL_ACTIONS, addActionCS(), NLAINIMAT::CConditionMap::addIfNotSensorCondition(), NLAINIMAT::CConditionMap::addIfSensorCondition(), addVirtualActionCS(), NLAINIMAT::CConditionMap::clear(), NLMISC::CIFile::close(), NLMISC::CIFile::getline(), NLAINIMAT::Motivation_Unknown, nlassert, NLMISC::CIFile::open(), NLAINIMAT::Sensor_Unknown, NLAINIMAT::CClassifierPriority::SetClassifierTimer(), NLAINIMAT::TAction, NLAINIMAT::TMotivation, NLAINIMAT::TSensor, uint, and uint32.
00392 {
00393 bool ret;
00394 const uint32 aboeufSize = 2048;
00395 char aboeuf[aboeufSize];
00396 std::string laLigne, leMot;
00397 uint lastPos = 0;
00398 uint nextPos = 0;
00399 NLMISC::CIFile melkior;
00400 CConditionMap conditionsMap;
00401 std::map<TAction, CActionClassifiers > actionsMap;
00402 std::vector<TSensor> sensorVector;
00403 ret = melkior.open(fileName, true);
00404 if (!ret) return false;
00405 // 1ère ligne : titre conditions
00406 melkior.getline(aboeuf, aboeufSize);
00407 // 2ème ligne : Motivations; [Condition]*; Actions; priority; blabla
00408 melkior.getline(aboeuf, aboeufSize);
00409 laLigne = aboeuf;
00410 // on construit une map avec les conditions
00411 nextPos = laLigne.find_first_of(";",lastPos);
00412 leMot = laLigne.substr(lastPos,nextPos - lastPos);
00413 nlassert(leMot == "Motivations");
00414 lastPos = nextPos+1;
00415 nextPos = laLigne.find_first_of(";", lastPos);
00416 leMot = laLigne.substr(lastPos, nextPos-lastPos);
00417 while (leMot != "Actions")
00418 {
00419 // on regarde le type du senseur :
00420 TSensor titi = conversionSensor.fromString(leMot);
00421 nlassert (titi != Sensor_Unknown);
00422 sensorVector.push_back(titi);
00423
00424 lastPos = nextPos+1;
00425 nextPos = laLigne.find_first_of(";", lastPos);
00426 leMot = laLigne.substr(lastPos, nextPos-lastPos);
00427 }
00428 // on parse le reste
00429 melkior.getline(aboeuf, aboeufSize);
00430 laLigne = aboeuf;
00431 lastPos = 0;
00432 nextPos = 0;
00433 while (laLigne.size() > 0)
00434 {
00435 TMotivation laMotive;
00436 TAction laVirtuelle;
00437 // On récupère le nom de la motivation
00438 nextPos = laLigne.find_first_of(";",lastPos);
00439 leMot = laLigne.substr(lastPos,nextPos - lastPos);
00440 if (leMot.size() == 0) break;
00441 laMotive = conversionMotivation.fromString(leMot);
00442 if (laMotive == Motivation_Unknown)
00443 {
00444 // Si c'est pas une motivation, c'est peut-être une action virtuelle.
00445 laVirtuelle = conversionAction.fromString(leMot);
00446 nlassert(laVirtuelle != Action_Unknown);
00447 }
00448
00449 lastPos = nextPos+1;
00450 nextPos = laLigne.find_first_of(";",lastPos);
00451 leMot = laLigne.substr(lastPos,nextPos - lastPos);
00452
00453 // On récupère la liste des conditions
00454 uint ii;
00455 for (ii = 0; ii < sensorVector.size(); ii++)
00456 {
00457 if (leMot.size() >0)
00458 {
00459 TSensor sensorName = sensorVector[ii];
00460 if (leMot[0] == '!')
00461 {
00462 conditionsMap.addIfNotSensorCondition(sensorName,leMot[1]);
00463 }
00464 else
00465 {
00466 conditionsMap.addIfSensorCondition(sensorName,leMot[0]);
00467 }
00468 }
00469
00470 lastPos = nextPos+1;
00471 nextPos = laLigne.find_first_of(";",lastPos);
00472 leMot = laLigne.substr(lastPos,nextPos - lastPos);
00473 }
00474 // on récupère le nom de l'action
00475 TAction actionName = conversionAction.fromString(leMot);
00476 nlassert(actionName != Action_Unknown);
00477
00478 lastPos = nextPos+1;
00479 nextPos = laLigne.find_first_of(";",lastPos);
00480 leMot = laLigne.substr(lastPos,nextPos - lastPos);
00481
00482 // on récupère la force du classeur
00483 CClassifierPriority laforce;
00484 laforce.SetClassifierTimer( atof(leMot.c_str()) );
00485
00486 // on rajoute la règle dans les actions.
00487 std::map<TAction, CActionClassifiers >::iterator itActionsMap = actionsMap.find(actionName);
00488 if (itActionsMap == actionsMap.end())
00489 {
00490 CActionClassifiers bibu(actionName);
00491 actionsMap.insert(std::make_pair(actionName, bibu));
00492 }
00493 CActionClassifiers mon_action(actionName);
00494 // Si la motivation est inconnue, c'est que c'est une action virtuelle.
00495 if (laMotive == Motivation_Unknown)
00496 {
00497 actionsMap[actionName].addVirtualActionRule(laVirtuelle,conditionsMap, laforce);
00498 }
00499 else
00500 {
00501 actionsMap[actionName].addMotivationRule(laMotive,conditionsMap, laforce);
00502 }
00503
00504 conditionsMap.clear();
00505 melkior.getline(aboeuf, aboeufSize);
00506 laLigne = aboeuf;
00507 lastPos = 0;
00508 nextPos = 0;
00509 }
00510 melkior.close();
00511
00512 std::map<TAction, CActionClassifiers >::iterator itActionsMap;
00513 for (itActionsMap = actionsMap.begin(); itActionsMap != actionsMap.end(); itActionsMap++)
00514 {
00515 //***G*** ajouter aussi la gestion des actions virtuels
00516 TAction testAction = (*itActionsMap).second.getName();
00517 nlassert (testAction != Action_Unknown);
00518 if (testAction > Action_VIRTUAL_ACTIONS)
00519 {
00520 addVirtualActionCS( (*itActionsMap).second );
00521 }
00522 else
00523 {
00524 addActionCS( (*itActionsMap).second );
00525 }
00526 }
00527
00528 return true;
00529 }
|
|
|
Definition at line 359 of file mhics.cpp. References _ActionSet, _MotivationClassifierSystems, _VirtualActionClassifierSystems, and nldebug.
00360 {
00361 std::string ret = "";
00362 nldebug("\n---------------------------");
00363 std::map<TMotivation, CClassifierSystem>::const_iterator itMotivationClassifierSystems;
00364 for (itMotivationClassifierSystems = _MotivationClassifierSystems.begin(); itMotivationClassifierSystems != _MotivationClassifierSystems.end(); itMotivationClassifierSystems++)
00365 {
00366 ret += (("\nMotivation : " + conversionMotivation.toString((*itMotivationClassifierSystems).first)).c_str());
00367 (*itMotivationClassifierSystems).second.getDebugString(ret);
00368 nldebug(ret.c_str());
00369 ret = "";
00370 }
00371 std::map<TAction, CClassifierSystem>::const_iterator itVirtualActionClassifierSystems;
00372 for (itVirtualActionClassifierSystems = _VirtualActionClassifierSystems.begin(); itVirtualActionClassifierSystems != _VirtualActionClassifierSystems.end(); itVirtualActionClassifierSystems++)
00373 {
00374 ret += (("\nVirtual Action : " + conversionAction.toString((*itVirtualActionClassifierSystems).first)).c_str());
00375 (*itVirtualActionClassifierSystems).second.getDebugString(ret);
00376 nldebug(ret.c_str());
00377 ret = "";
00378 }
00379 ret += ("\nACTIONS :\n");
00380 std::set<TAction>::const_iterator itActionSet;
00381 for (itActionSet = _ActionSet.begin(); itActionSet != _ActionSet.end(); itActionSet++)
00382 {
00383 ret += ((conversionAction.toString((*itActionSet)) + "\n").c_str());
00384 nldebug(ret.c_str());
00385 ret = "";
00386 }
00387 }
|
|
||||||||||||||||
|
Select a behavior according to the values in the sensorMap.
Definition at line 256 of file mhics.cpp. References _MotivationClassifierSystems. Referenced by NLAINIMAT::CMHiCSagent::motivationCompute().
00259 {
00260 std::map<TMotivation, CClassifierSystem>::iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00261 if (itMotivationClassifierSystems != _MotivationClassifierSystems.end())
00262 {
00263 (*itMotivationClassifierSystems).second.selectBehavior(psensorMap, mapActivableCS);
00264 }
00265 }
|
|
||||||||||||||||
|
Set a new value for a classifier priority.
Definition at line 320 of file mhics.cpp. References _MotivationClassifierSystems, nlassert, and NLAINIMAT::TClassifierNumber.
00321 {
00322 std::map<TMotivation, CClassifierSystem>::iterator itMotivationClassifierSystems = _MotivationClassifierSystems.find(motivationName);
00323 nlassert(itMotivationClassifierSystems != _MotivationClassifierSystems.end());
00324 (*itMotivationClassifierSystems).second.setPriorityPart(classifierNumber, priority);
00325 }
|
|
|
Definition at line 190 of file mhics.h. Referenced by addActionCS(), getDebugString(), isAnAction(), and printDebugString(). |
|
|
Definition at line 188 of file mhics.h. Referenced by addVirtualActionCS(), dbgPrintClassifierPriorityInFile(), getActionPart(), getDebugString(), getPriorityPart(), learningUpdatePriorityValueClassifierTime(), learningUpdatePriorityValueTimeToSuccess(), printDebugString(), selectBehavior(), and setPriorityValue(). |
|
|
Definition at line 189 of file mhics.h. Referenced by addVirtualActionCS(), getDebugString(), and printDebugString(). |
|
|
Definition at line 185 of file mhics.h. Referenced by CMHiCSbase(), NLAINIMAT::CMHiCSagent::selectBehavior(), and ~CMHiCSbase(). |
1.3.6