diff --git a/doc/report/algos.tex b/doc/report/algos.tex
index a4323e1d1cba9a6eb3b3712a3137116b783b5220..6d5b312efbb15d9cc85f3f9b52d501d4098e67e8 100644
--- a/doc/report/algos.tex
+++ b/doc/report/algos.tex
@@ -5,6 +5,21 @@ Both MGM and MGM-2 algorithms are described here.
\subsection{MGM}
+ % \subsubsection{Algorithm}
+
+ The algorithm is described in Algorithms~\ref{algo:MGM-agent}, \ref{algo:MGM-system},
+ \ref{algo:MGM-evaluate}, \ref{algo:MGM-decide},
+ \ref{algo:MGM-communicateValue}, \ref{algo:MGM-getValue},
+ \ref{algo:MGM-getAllValues}, \ref{algo:MGM-makeAllOffers},
+ \ref{algo:MGM-makeOffer},
+ \ref{algo:MGM-getOffer}, \label{algo:MGM-getAllOffers}
+
+We define $N(a_i)$ the set of neighbouring agents for $a_i$:
+\begin{center}
+ $N : A \rightarrow 2^A$\\ $a_i \mapsto N_i= N(a_i) =$
+ \end{center}
+
+
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{algorithm}
\DontPrintSemicolon
@@ -31,6 +46,7 @@ Both MGM and MGM-2 algorithms are described here.
}
supervisor ! informValue(self.val)
\caption{Agent-centered view of MGM}
+ \label{algo:MGM-agent}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -50,8 +66,9 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
currentGlobalContext $\mapsfrom$ currLocContext $\forall a \in A$
-\KwReturn{currentGlobalContext}
-\caption{System-centered view of MGM}
+ \KwReturn{currentGlobalContext}
+ \caption{System-centered view of MGM}
+ \label{algo:MGM-system}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -76,6 +93,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
\KwReturn{(bestVal, best-$\delta$)}
\caption{Evaluate}
+ \label{algo:MGM-evaluate}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -98,6 +116,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
\KwReturn{advice}
\caption{Decide}
+ \label{algo:MGM-decide}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -124,6 +143,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
msg $\mapsfrom$ send($v$, $a_i$)\\
\KwReturn{msg}
\caption{communicateValue}
+ \label{algo:MGM-communicateValue}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -136,6 +156,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
msg $\mapsfrom$ receive(communicateValue($a_i, a, v \in D_x$))\\
\KwReturn{msg}
\caption{getValue}
+ \label{algo:MGM-getValue}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -151,6 +172,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
\KwReturn{currLocContext}
\caption{GetAllValues}
+ \label{algo:MGM-getAllValues}
\end{algorithm}
@@ -166,6 +188,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
\KwReturn{$(\delta_a$, $a)$}
\caption{makeAllOffers}
+ \label{algo:MGM-makeAllOffers}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -178,6 +201,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
offer $\mapsfrom$ send($\delta_a$, $a_i$)\\
\KwReturn{offer}
\caption{makeOffer}
+ \label{algo:MGM-makeOffer}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -189,6 +213,7 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
offer $\mapsfrom$ receive(makeOffer($\delta_a, a)$))\\
\KwReturn{offer}
\caption{getOffer}
+ \label{algo:MGM-getOffer}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -203,23 +228,25 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
}
\KwReturn{$\{(\delta_{ai}$, $a_i)\}$}
\caption{GetAllOffers}
+ \label{algo:MGM-getAllOffers}
\end{algorithm}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
- \subsubsection{Algorithm}
- \begin{figure}
- \centering
- $N : A \rightarrow 2^A$\\ $a_i \mapsto N_i= N(a_i) =$ the set of neighbouring agents for $a_i$
- \caption{Neighbourhood}
- \end{figure}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+
+
\subsection{MGM-2}
+ Algorithm~\ref{algo:MGM-2} and its sub-algorithms\ref{algo:MGM-2-inform}, \ref{algo:MGM-2-offer}, \ref{algo:MGM-2-evaluate}, \ref{algo:MGM-2-inform2} and \ref{algo:MGM-2-go-no-go} present MGM-2.
+
\begin{algorithm}
\DontPrintSemicolon
@@ -227,20 +254,43 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
\KwOutput{A solution to the DCOP}
\While{not terminated}
{
- Inform: \For{each agent $a_i$ in A}{
+ Inform\\
+ Determine offerers/receivers as resp. O and R\\
+ Offer\\
+ Evaluate\\
+ Inform2\\
+ Go/No-Go \\
+ The agent with $max(bm_x)$ wins the round and is allowed to act
+ }
+ \caption{MGM-2}
+ \label{algo:MGM-2}
+ \end{algorithm}
+
+
+ \begin{algorithm}
+ \For{each agent $a_i$ in A}{
\For{each agent $a_j$ in A}{
\If{$a_i$ and $a_j$ share a function $f_m$} {
$a_i$ informs $a_j$ of the $x_i$ value it controls in $f_m$
}
}
}
- Determine offerers/receivers as resp. O and R\\
- Offer: \For{each agent $a_i$ in O}{
+ \caption{MGM-2 Inform }
+ \label{algo:MGM-2-inform}
+ \end{algorithm}
+
+ \begin{algorithm}
+ \For{each agent $a_i$ in O}{
offerer sends $(a_i,a_j,gain^O(a_i,a_j))$ where $gain^O(a_i,a_j))$ is offerer's \textbf{local utility gain} for suggested values $a_i$ and $a_j$.
Chose at random an agent $a_j$ in R sharing a function $f_m$ with self
Send offer message containing all coordinated moves for the pair $(a_i,a_j)$ which improve current $f_m$
}
- Evaluate: \For{each agent $a_i$ in R}{
+ \caption{MGM-2 Offer}
+ \label{algo:MGM-2-offer}
+ \end{algorithm}
+
+ \begin{algorithm}
+ \For{each agent $a_i$ in R}{
Compute improvement $\delta$ achievable, taking into account $f_m$ offer and its own function $f_n$ \\
If $gain^R(a_i,a_j)$ is receiver's \textbf{local utility }gain for suggested values $a_i$ and $a_j$\\
for each $(a_i,a_j)$, compute $globalGain(a_i,a_j) = gain^R(a_i,a_j)+gain^O(a_i,a_j) - \Delta(a_i,a_j)$ where $\Delta(a_i,a_j)$ = how much ``link between both'' changes using $(a_i,a_j)$ ( not very clear in Mashewaran (fin page 4)).)\\
@@ -249,7 +299,12 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
Offerer and receiver are now committed
}
}
- Inform: \For{each agent in A}{
+ \caption{MGM-2 Evaluate}
+ \label{algo:MGM-2-evaluate}
+ \end{algorithm}
+
+ \begin{algorithm}
+ For{each agent in A}{
Send a gain message to all neighbours\\
\If{agent is committed}{
Gain message is for coordinated move
@@ -258,7 +313,12 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
Gain message is best $bm$ for unilateral move
}
}
- Go/No-Go: \For{each agent $a_i$ in A}{
+ \caption{MGM-2 Inform2}
+ \label{algo:MGM-2-inform2}
+ \end{algorithm}
+
+ \begin{algorithm}
+ \For{each agent $a_i$ in A}{
\If{$a_i$ is in C}{
\If{$a_i$'s offer was the best of the neighbourhood}{
$a_i$ send its committed partner $a_j$ a \textit{go} message
@@ -271,9 +331,8 @@ a boolean b set to true if the goal is miniMax, false if maxiMin}
Uncommitted agents act if their offer was the best in their neighbourhood
}
}
- The agent with $max(bm_x)$ wins the round and is allowed to act
- }
-\caption{MGM-2}
-\end{algorithm}
+ \caption{MGM-2 Go/No-Go}
+ \label{algo:MGM-2-go-no-go}
+ \end{algorithm}
diff --git a/doc/report/fsm.tex b/doc/report/fsm.tex
index 126600198d7033d6d18551f7fa0b0118771b56b7..b31d994ff91bff3fe525ee04200cd675c919fb96 100644
--- a/doc/report/fsm.tex
+++ b/doc/report/fsm.tex
@@ -6,7 +6,7 @@ Agents systematically base their decision on their local knowledge.
The process is triggered by a supervisor agent who invites other agents to begin their rounds of interactions.
Each agent $a_i$ is sent a \beginAlgo{} message by the supervisor and initiates its variable's value at random in the variable's domain.
-The behaviour of each agent is defined by a finite state automata.
+The behaviour of each agent is defined by a finite state automata (see Figure~\ref{full_agent} for the big picture and Figures~\ref{beginning}, \ref{offerer}, \ref{receiver}, \ref{committed} and \ref{uncommitted} for focused extracts ).
\subsection{ Agent States}
@@ -55,7 +55,7 @@ Messages received in this state are: \begin{itemize}
\item \beginAlgo{}: upon receiving a \beginAlgo, sent by the supervisor,
%
-agent performs a \initRandomVal{\val.domain} operation, this method is called only once per algorithm execution for each agent.
+agent performs a \initRandomVal{\val.domain} operation, this me\-thod is called only once per algorithm execution for each agent.
%
The agent unstashes all previous \informVal{} stashed messages and sends a \kickStart{} message to the Supervisor.
%
@@ -76,7 +76,7 @@ Messages received in this state: \begin{itemize}
\item \giveNoGo{}: If the agent has reached this state after completing a round where it had been committed but could not act because it did not win the neighbourhood's delta competition, it will receive its partners' \giveGo{} or \giveNoGo{} here, but nothing should be done about it.
\item \stopAlgo{}: agent transitions to \final{} with the whole process terminating
\item \continueAlgo{}: agent called \reset{} method, emptying\linebreak \receivedOffers{}, \neighbourValues{} and \neighbourDeltas{}.
- early received \informVal{} messages are unstashed, then the agent sends its own value via \informVal{\val} to all its neighbours. It performs \determineSubset{} and send the outcome to self via \chooseSubset{} before transitioning to \waitingForRole{} where \chooseSubset{} will be dealt with as well as unstashed \informVal{}.
+ early received \informVal{} messages are unstashed, then the agent sends its own value via \informVal{\val} to all its neighbours. It performs \determineSubset{} and send the outcome to self via \linebreak \chooseSubset{} before transitioning to \waitingForRole{} where \chooseSubset{} will be dealt with as well as unstashed \informVal{}.
\end{itemize}
@@ -84,7 +84,7 @@ Messages received in this state: \begin{itemize}
This state acts as a crossroads between paths as Offerer or Receiver.
Messages received in this state: \begin{itemize}
\item \informVal{someVal}: are stashed to be dealt with when leaving this state for the targeted next one.
- \item \chooseSubset{someSubset}: triggers a transition to either \offWaitingValues{} or \recWaitingOffers{} according to the value of \textit{someSubset}.
+ \item \chooseSubset{someSubset}: triggers a transition to either\linebreak \offWaitingValues{} or \recWaitingOffers{} according to the value of \textit{someSubset}.
\end{itemize}
\begin{figure}
@@ -108,10 +108,10 @@ Before transitioning to the next state, the agent will wait here for the potenti
Messages received in this state: \begin{itemize}
\item \makeOff{someOffer}: message is still answered with a \reject.
\item \informDelta{someDelta}: messages received from neighbours which are one step ahead are stashed at this stage.
- \item \accept{someCombinedMove}: it will transition to committed and set \commitment{} to true as well as set \partner{} to \accept{someOffer}'s sender, this data will also help to compute the new delta.\\
- \informDelta{\neighbourDeltas.get(self.variable)} is sent to all neighbours after having computed its new delta either through it's partner's \accept{someCombinedMove}'s delta or on its own if it has been rejected with \computeSoloDelta{}.
- \item \reject{someOffer}: the agent will transition to \uncommitted{}, set \commitment{} to true and set \partner{} to \texttt{None}.
- \informDelta{\neighbourDeltas.get(self.variable)}: sent to all neighbours after having computed its new delta either through it's partner's \accept{someCombinedMove}'s delta or on its own if it has been rejected with \computeSoloDelta{}.
+ \item \accept{someCombinedMove}: it will transition to committed and set \commitment{} to true as well as set \partner{} to \linebreak \accept{someOffer}'s sender, this data will also help to compute the new delta.\\
+ \informDelta{\neighbourDeltas.get(self.variable)} is sent to all neighbours after having computed its new delta either through it's partner's \linebreak \accept{someCombinedMove}'s delta or on its own if it has been rejected with \computeSoloDelta{}.
+ \item \reject{someOffer}: the agent will transition to \uncommitted{}, set\linebreak \commitment{} to true and set \partner{} to \texttt{None}.
+ \\ \informDelta{\neighbourDeltas.get(self.variable)} is sent to all neighbours after having computed its new delta either through it's partner's\linebreak \accept{someCombinedMove}'s delta or on its own if it has been rejected with \computeSoloDelta{}.
\end{itemize}
\begin{figure}
@@ -125,17 +125,17 @@ In this state the Receiver agent waits until it has been informed of all its nei
Messages received in this state: \begin{itemize}
\item \informVal{someVal}: are stored in the \neighbourValues{} map and become relevant only if the receiver does not get any acceptable offer.
Once all of them have been received, the agent transitions to \recWaitingOffers{}.
- \item \makeOff{None/someOffer}: are stashed to be handled in \recWaitingOffers{}.
+ \item \makeOff{None/someOffer}: are stashed to be handled in\linebreak \recWaitingOffers{}.
\end{itemize}
\subsubsection{\recWaitingOffers{}}
The last offer to be received causes the transition to the next state.
-At the end, when the last offer is received, whether the agent has received a real or \texttt{None} last offer, it will process the list of real offers received with \linebreak \determineBestOffer{}.
+At the end, when the last offer is received, whether the agent has received a real or \texttt{None} last offer, it will process the list of real offers received with \linebreak \determineBestOffer{}.\\
Messages received in this state: \begin{itemize}
\item \makeOff{someOffer}: stored in \receivedOffers{} map until all offers have been received.
\item \makeOff{None}: a counter is simply increased to keep track of the number and know when all offers ahev been received.
\end{itemize}
-Once all offers have been received, the agent computes the result of\linebreak \determineBestOffer{} and sends it to itself with \bestOfferFM{someOffer} which will be handled in the next state \recHavingRecAllOff{}.
+Once all offers have been received, the agent computes the result of\linebreak \determineBestOffer{} and \linebreak sends it to itself with \bestOfferFM{someOffer} which will be handled in the next state \recHavingRecAllOff{}.
\subsubsection{\recHavingRecAllOff{}}
@@ -144,20 +144,20 @@ Messages received in this state: \begin{itemize}
\item \informDelta{someDelta}: will be stashed and handled in either \committed{} or \uncommitted{}.
\item \bestOfferFM{someOffer}: will cause the agent to transition to \committed{}, setting \commitment{} to \texttt{true} and setting its \partner{} variable to the agent it has committed with.
the agent's current delta value is computed with \computeJointDelta{somePartner}.
- it will send a \reject{} to all neighbours which are not the partner and an \accept{someCombinedMove} to the chosen partner.
+ It will send a \reject{} to all neighbours which are not the partner and an\linebreak \accept{someCombinedMove} to the chosen partner.
\item \bestOfferFM{None}: will cause the agent to transition to \uncommitted{} and set its \commitment{} to \texttt{false}.
- It will send a \reject{} to all neighbours. The agent's current delta value is computed with \linebreak\computeSoloDelta{} and added to \neighbourDeltas.
+ It will send a \reject{} to all neighbours. The agent's current delta value is computed with \linebreak\computeSoloDelta{} and added to \linebreak\neighbourDeltas.
\end{itemize}
-In both \bestOfferFM{None/someOffer} cases, \informDelta{someDelta} is sent to all neighbours, containing either the result of \computeJointDelta{someDelta} or \computeSoloDelta{}.
+In both \bestOfferFM{None/someOffer} cases, \informDelta{someDelta} is sent to all neighbours, containing either the result of \linebreak\computeJointDelta{someDelta} or \linebreak\computeSoloDelta{}.
\begin{figure}
- \center{\includegraphics[width=\textwidth]{figures/fsm/committed.png}}
+ \center{\includegraphics[height=\textheight]{figures/fsm/committed.png}}
\caption{Committed agent}
\label{committed}
\end{figure}
\subsubsection{\committed{}}
-This state can be reached from \recHavingRecAllOff{} or \offMakingOff{}.
+This state can be reached from \recHavingRecAllOff{} or \linebreak \offMakingOff{}.
Messages received in this state: \begin{itemize}
\item \informDelta{someDelta}: messages are added to \neighbourDeltas{} until they have been received from all neighbours.
When all deltas have been received, the best delta of the neighbourhood can be computed.
@@ -171,7 +171,7 @@ Messages received in this state: \begin{itemize}
\end{figure}
\subsubsection{\uncommitted{}}
-Similarly to \committed{}, this state can be reached either from \recHavingRecAllOff{} or \offMakingOff{}.
+Similarly to \committed{}, this state can be reached either from\linebreak \recHavingRecAllOff{} or \offMakingOff{}.
Messages received in this state: \begin{itemize}
\item \informDelta{someDelta}: are added to \neighbourDeltas{} until it they have been received from all neighbours.
Once all deltas have been received, it will compute whether it should act or not based on neighbourhood deltas and send either send \shouldAct{true} or \shouldAct{false} and transition to \actSolo{}.
@@ -182,7 +182,7 @@ Messages received in this state: \begin{itemize}
Here the uncommitted agent processes the \shouldAct{true/false} message, it will transition to \continue{} either way.
Messages received in this state: \begin{itemize}
\item \shouldAct{true}: \val{} will be updated to \computeNewVal{}, inform supervisor of current value with \informVal{\val}.
- \item \shouldAct{false}: nothing except inform supervisor of current value with \informVal{\val}.
+ \item \shouldAct{false}: nothing except inform supervisor of current value with \linebreak\informVal{\val}.
\end{itemize}
@@ -192,7 +192,7 @@ Hence the agent migh receive its partner's \giveGo{} or \giveNoGo{} message whic
In any case, the agent handles the self-sent message \shouldAct{true/false}.
Messages received in this state: \begin{itemize}
\item \shouldAct{false}: it will send its partner a \giveNoGo{} signal and transition to \continue{} by sending the Supervisor the \informVal{\val}.
- \item \shouldAct{true}: the agent sends its partner a \giveGo{} and transitions to \handlingGNG{}.
+ \item \shouldAct{true}: the agent sends its partner a \giveGo{} and transitions to \linebreak\handlingGNG{}.
\end{itemize}
@@ -234,7 +234,7 @@ In order to carry out negotiations, exchange information and coordiante themselv
Each message can only be handled in dedicated states and will therefore be stashed for later use when received in a non-dedicated state.
\subsubsection{Standard agent messages}
\begin{itemize}
- \item \kickStart{}: is sent by the agent at the very begining of the process to indicate to the Supervisor that it needs to send it the initial \continueAlgo message.
+ \item \kickStart{}: is sent by the agent at the very begining of the process to indicate to the Supervisor that it needs to send it the initial \continueAlgo{} message.
\item \chooseSubset{Offerer/Receiver}: is sent by the agent to itself, sent in the \waitingForRole{} state and then causing the transition towards either \offWaitingValues{} or \recWaitingOffers{}. This message determines the path the agent threads for the next two states before joigning again in the \uncommitted{}/\uncommitted{} states.
\item \informVal{someVal}: is sent by an agent to all neighbouring agents in state \waitingForRole{}.
\item \informDelta{\neighbourDeltas.get(self.variable)}: is sent by an agent which has computed its solo or joint delta to its neighbourhood upon transitioning to either \uncommitted{} or \uncommitted{} states.
@@ -268,7 +268,7 @@ From there, it will branch, either back to the other state or to the final one o
\subsubsection{General overview}
\begin{itemize}
\item \waitingAgentValues{}: the main state where supervisor waits for agents' information.
- \item \startState{}: the state in which the supervisor starts, from there it broadcasts the \trigger message to all agents and directly goes to \waitingAgentValues.
+ \item \startState{}: the state in which the supervisor starts, from there it broadcasts the \trigger message to all agents and directly goes to \linebreak\waitingAgentValues.
\item \decidingStopContinue{}: state in which the supervisor checks whether the stopping condition has been met or not.
\item \finishState{}: the final state the supervisor ends in after the full algorithm has ended and the stopping condition is met.
\end{itemize}
@@ -283,7 +283,7 @@ From there, it will branch, either back to the other state or to the final one o
This is the main state the supervisor spends most time in. Here it collects values from agents in order to make its decision.
Messages received in this state: \begin{itemize}
\item \kickStart{}: this is directly answered with a \continueAlgo{} message.
- \item \informVal{someVal}: these messages are put into the supervisors' \currentContext until it is filled.
+ \item \informVal{someVal}: these messages are put into the supervisors' \linebreak\currentContext until it is filled.
The last one triggers a transition to \decidingStopContinue{}.
\end{itemize}
@@ -301,7 +301,7 @@ Final state of the automaton, no messages are received here.
\subsection{Supervisor's mental state}
-The supervisor only handles one mental state variable: \currentContext{}.
+The supervisor only handles one mental state variable:\linebreak \currentContext{}.
In it it stores the current values all variables have.
\subsection{Supervisor messages}
diff --git a/doc/report/main.tex b/doc/report/main.tex
index e0d58844fee35733dd3da7161f9a37209902f973..fcc3a3e1bf97a9bd03874b7effcb25a0148456a4 100644
--- a/doc/report/main.tex
+++ b/doc/report/main.tex
@@ -92,7 +92,7 @@
\newcommand{\informVal}[1]{\texttt{InformValue}(#1)}
\newcommand{\makeOff}[1]{\texttt{MakeOffer}(#1)}
\newcommand{\accept}[1]{\texttt{Accept}(#1)}
-\newcommand{\reject}{\texttt{Reject}}
+\newcommand{\reject}[1]{\texttt{Reject}(#1)}
\newcommand{\bestOfferFM}[1]{\texttt{BestOfferForMe}(#1)}
\newcommand{\shouldAct}[1]{\texttt{Act}(#1)}
\newcommand{\giveGo}{\texttt{GiveGo}}
@@ -122,7 +122,7 @@
\newcommand{\initRandomVal}[1]{\texttt{mind.choose(variable)}(#1)}
\newcommand{\reset}{\texttt{mind.reset()}}
\newcommand{\determineSubset}{\texttt{mind.determineSubset(threhold)}}
-\newcommand{\computeSoloDelta}{\texttt{mind.computeSoloDelta(bestUnilateralMove)}}
+\newcommand{\computeSoloDelta}{\texttt{mind.computeSoloDelta}(bestUnilateralMove)}
\newcommand{\computeJointDelta}[1]{\texttt{mind.computeJointDelta}(#1)}
\newcommand{\determineBestOffer}{\texttt{mind.chooseBestSingleOffer(variable, neighbours, constraints)}}
%??