class Option : public Constraint

Basisklasse fuer alle umsetzbaren Handlungsmoeglichkeiten des Agenten

Inheritance:


Public Methods

virtual void adaptToPreviousIntention( const Option *previousIntention )
Anpassung an die bisherige Absicht
virtual int cancellationCost()
Gibt die Abbruchkosten an
virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurueck
virtual bool forceContinuation()
Soll die Absicht unbedingt beibehalten werden? Manche Optionen koennen oder sollen nicht jederzeit abgebrochen werden
virtual Plan generatePlan()
Erzeugt einen Plan zur Umsetzung der Option
virtual bool isPossible()
Prueft, ob die Option tatsaechlich umsetzbar ist
Option()
Erzeugt eine UNDEF_OPTION
void setConstraints( const Array<Constraint *>& constraints )
Fordert, dass der Nutzen unter Beruecksichtigung der angegebenen Nebenbedingungen berechnet wird
virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal
virtual ~Option()
Virtueller Destruktor

Protected Fields

mutable Array <Constraint *> acceptedConstraints
Hier stehen die bei der Nutzenberechnung akzeptierten Nebenbedingungen
Array <Constraint *> requestedConstraints
Hier stehen die ueber setConstraints angeforderten Nebenbedingungen

Protected Methods

virtual int baseUtility()
Der Grundnutzen der Option
int computeExpectedUtility()
Fuehrt die eigentliche Berechnung der expectedUtility durch
virtual int constraintCost( const Constraint *constraint )
Liefert die Kosten, die durch die Einhaltung einer Nebenbedingung entstehen
bool isConstraintAccepted( int constraintId )
Gibt an, ob eine Nebenbedingung unter den akzeptierten ist
bool isOptionPossible()
Erfragt ob die Option prinzipiell moeglich ist
void setIsOptionPossible( bool isOptionPossible )
Setzt, ob es möglich ist diese Option durchzuführen

Private Fields

mutable bool theIsOptionPossible
Variabel die aussagt, ob die Option durchführbar ist

Inherited from Constraint:

Public Methods

int expectedUtility()
int id()

Protected Fields

mutable int simStepOfUtilityCalculation
mutable int theExpectedUtility
int theId

Inherited from StorableObject:

Public

Ausgabe auf dem Terminal

void printOn(ostream& = cout)
Ausgabe der Beschreibung auf einen Stream
virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal

Objekte anlegen und zerstören

virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurück
virtual ~StorableObject()
Der virtuelle Destruktor

Documentation

Basisklasse fuer alle umsetzbaren Handlungsmoeglichkeiten des Agenten. Jedes Objekt dieser Klasse steht fuer eine Option, die eine konkrete Aktionsfolge zur Umsetzung erzeugen kann. Ebenso wie bei Constraints haengt die Utilityberechnung von Wuenschen von der aktuellen Situation ab. Zusaetzlich werden aber einschraenkende Wuensche (Nebenbedingungen) beachtet. Nebenbedingungen muessen von Constraint abstammen.

Jedesmal, nachdem sich die aktuelle Situation im Weltmodell oder die Liste der zu beruecksichtigenden Nebenbedingungen geaendert hat, wird die expectedUtility (der Nutzen) neu berechnet.

Auch von Option selbst koennen Instanzen erzeugt werden. Sie werden zur Initialisierung im Deliberator und als letzter Fallback bei der Intentionerzeugung verwendet. Normalerweise werden aber nur von Nachkommen von Option Instanzen erzeugt.

Mit den uebergebenen Arrays von Zeigern auf Constraints wird keine Verantwortung fuer Constraint-Objekte uebergeben. Das die Option besitzende Objekte muss garantieren, dass Zeiger waerend der Lebensdauer der Option gueltig bleiben.

Quelltext

[Header | [Implementierung]

CVS Informationen zum Interface

  **************************************************
  *
  * Aktueller Stand
  *
  *   $RCSfile: Option.h,v $
  *   $Revision: 1.13 $
  *   $Date: 1998/08/14 13:21:02 $
  *   $Author: myritz $ 
  *
  **************************************************
  
Option()
Erzeugt eine UNDEF_OPTION

void setConstraints( const Array<Constraint *>& constraints )
Fordert, dass der Nutzen unter Beruecksichtigung der angegebenen Nebenbedingungen berechnet wird. Das heisst NICHT, dass die Nebenbedingungen beachtet werden, sondern nur, dass die durch ihre Verletzung entstehenden Nachteile in die Berechnung des Nutzens einfliessen.
Parameters:
constraints - Container mit den Nebenbedingungen

virtual int cancellationCost()
Gibt die Abbruchkosten an. Das sind Kosten, die entstehen, wenn bereits mit der Umsetzung begonnen wurde und nun eine andere Option gewaehlt wird. Hohe Abbruchkosten entstehen vor allem, wenn eine gemeinsame Absicht des Teams aufgegeben wird.
Returns:
Im Allgemeinen ein Wert zwischen NEUTRAL_COST und MAX_COST, bei Option selbst NEUTRAL_COST.

virtual bool isPossible()
Prueft, ob die Option tatsaechlich umsetzbar ist. Es kann sein, dass sie nicht umsetzbar ist, da zur Berechnung des Nutzens Heuristiken verwendet werden. Moeglicherweise laesst sich also kein Plan zur Umsetzung der Option erzeugen.

Die Berechnung von isPossible ist deutlich aufwendiger als die Berechnung der expectedUtility. Wurde die Utility noch nicht berechnet, muss sie zunaechst berechnet werden, um festzulegen, welche Constraints beruecksichtigt werden muessen. Danach wird ein Planskelett erzeugt (wenn nicht bereits eines existiert), das dann garantiert umsetzbar ist.

Das Ergebnis wird gecacht, so dass ein wiederholter Aufruf der Funktion in derselben Situation schnell zu demselben Ergebnis fuehrt.

Returns:
YES oder NO.

virtual bool forceContinuation()
Soll die Absicht unbedingt beibehalten werden? Manche Optionen koennen oder sollen nicht jederzeit abgebrochen werden. Diese Methode sollte wird vom Deliberator vor jedem Entscheidungsvorgang gefragt, ob die aktuelle Absicht weitergemacht werden soll. Beim Überschreiben in Subklassen sollte man Vorsicht walten lassen. Standardmäßig liegert die Methode NO zurück.
Returns:
YES oder NO.

virtual void adaptToPreviousIntention( const Option *previousIntention )
Anpassung an die bisherige Absicht. Die Anpassung kann die tatsaechliche Utility des Agenten verbessern, da es so aussieht, als wuerde er den bisherigen Plan weiterverfolgen, obwohl inzwischen sein Wunsch ein neuer ist. Die Default-Methode nimmt keine Anpassungen vor.

virtual Plan generatePlan()
Erzeugt einen Plan zur Umsetzung der Option. Wurde die Umsetzung des Plans bereits teilweise erledigt, so stellt dies generatePlan() fest und erzeugt die naechsten Schritte ausgehend von der aktuellen Situation im Weltmodell.
Returns:
Plan, der die ersten Schritte zur Umsetzung der Absicht enthaelt. Die Zahl der Schritte laesst sich konfigurieren (Variable maxLengthOfPlan in agent.conf).

virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal

virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurueck. Diese Methode muss fuer JEDE Unterklasse neu definiert werden.

virtual ~Option()
Virtueller Destruktor

Array <Constraint *> requestedConstraints
Hier stehen die ueber setConstraints angeforderten Nebenbedingungen

mutable Array <Constraint *> acceptedConstraints
Hier stehen die bei der Nutzenberechnung akzeptierten Nebenbedingungen

int computeExpectedUtility()
Fuehrt die eigentliche Berechnung der expectedUtility durch. Der Mechanismus ist wesentlich aufwendiger als bei reinen Constraints, da die Nebenbedingungen mitberuecksichtigt werden muessen. Diese Methode ist const, obwohl sie interne Werte umsetzt (acceptedConstraints).

virtual int baseUtility()
Der Grundnutzen der Option. Dieser Teil der Nutzenberechnung ist nur vom Weltmodell abhaengig.
Returns:
Im Allgemeinen ein Wert zwischen MAX_UTILITY und MIN_UTILITY. Option selbst liefert MIN_UTILITY.

virtual int constraintCost( const Constraint *constraint )
Liefert die Kosten, die durch die Einhaltung einer Nebenbedingung entstehen. Es gibt drei Arten von Nebenbedingungen. (1) Solche, die die zugehoerige Absicht einbeziehen kann, (2) neutrale, die ohne weiteren Aufwand nebenbei miterfuellt werden, und (3) andere, die entweder spaeter hinzugekommen oder unerfuellbar sind.

Die Kosten fuer (1) sind abhaengig von der Option und vom Weltmodell.

Nebenbedingungen vom Typ (2) haben die Kosten NEUTRAL_COST.

Die Kosten der Einhaltung einer unbekannten Nebenbedingung sind MAX_COST. Dadurch versucht die Option nie, sie zu erfuellen.

Returns:
Im allgemeinen Fall ein Wert zwischen NEUTRAL_COST und MAX_COST. Option selbst liefert fuer alle Constraints MAX_COST.
Parameters:
constraint - Die einzuhaltende Nebenbedingung

bool isConstraintAccepted( int constraintId )
Gibt an, ob eine Nebenbedingung unter den akzeptierten ist. Gibt YES zuruück, wenn eines der Constraints in acceptedConstraints die als Parameter angegebene Id hat.
Returns:
YES oder NO
Parameters:
constraintId - eine ConstraintId

void setIsOptionPossible( bool isOptionPossible )
Setzt, ob es möglich ist diese Option durchzuführen

bool isOptionPossible()
Erfragt ob die Option prinzipiell moeglich ist
Returns:
NO, wenn schon bei der Utility-berechnung die Unmoeglichkeit festgestellt wurde, sont YES

mutable bool theIsOptionPossible
Variabel die aussagt, ob die Option durchführbar ist


Direct child classes:
PassiveOption
KickOption

alphabetic index hierarchy of classes


Hauptseite

Einleitung | Architektur | Dynamische Zusammenhänge | Referenzhandbuch | FAQ | Anhang A | Anhang B

generated by doc++