Rationalise implementation of outcome objects

tturocy · tturocy · commit 6ef5d57285ee · 2025-03-25T10:26:12.000Z
This performs some outstanding rationalisation of `GameObjectRep` objects: * Removes indexing of payoffs by player index * Templates `GetPayoff` to obtain payoffs directly in the desired representation * Store payoffs using a `std::map` instead of `Array`. Closes #490.
diff --git a/src/games/behavmixed.cc b/src/games/behavmixed.cc
@@ -381,7 +381,7 @@ void MixedBehaviorProfile<T>::GetPayoff(const GameNode &node, const T &prob,
                                         const GamePlayer &player, T &value) const
 {
   if (node->GetOutcome()) {
-    value += prob * static_cast<T>(node->GetOutcome()->GetPayoff(player));
+    value += prob * node->GetOutcome()->GetPayoff<T>(player);
   }
 
   if (!node->IsTerminal()) {
@@ -520,7 +520,7 @@ void MixedBehaviorProfile<T>::ComputePass2_beliefs_nodeValues_actionValues(
   if (node->GetOutcome()) {
     GameOutcome outcome = node->GetOutcome();
     for (auto player : m_support.GetGame()->GetPlayers()) {
-      map_nodeValues[node][player] += static_cast<T>(outcome->GetPayoff(player));
+      map_nodeValues[node][player] += outcome->GetPayoff<T>(player);
     }
   }
 
diff --git a/src/games/behavpure.cc b/src/games/behavpure.cc
@@ -49,7 +49,7 @@ T PureBehaviorProfile::GetPayoff(const GameNode &p_node, const GamePlayer &p_pla
   T payoff(0);
 
   if (p_node->GetOutcome()) {
-    payoff += static_cast<T>(p_node->GetOutcome()->GetPayoff(p_player));
+    payoff += p_node->GetOutcome()->GetPayoff<T>(p_player);
   }
 
   if (!p_node->IsTerminal()) {
diff --git a/src/games/game.cc b/src/games/game.cc
@@ -41,9 +41,11 @@ namespace Gambit {
 //                       class GameOutcomeRep
 //========================================================================
 
-GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number)
-  : m_game(p_game), m_number(p_number), m_payoffs(m_game->NumPlayers())
+GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number) : m_game(p_game), m_number(p_number)
 {
+  for (const auto &player : p_game->GetPlayers()) {
+    m_payoffs[player] = Number();
+  }
 }
 
 //========================================================================
diff --git a/src/games/game.h b/src/games/game.h
@@ -121,7 +121,7 @@ class GameOutcomeRep : public GameObject {
   GameRep *m_game;
   int m_number;
   std::string m_label;
-  Array<Number> m_payoffs;
+  std::map<GamePlayerRep *, Number> m_payoffs;
 
   /// @name Lifecycle
   //@{
@@ -143,12 +143,8 @@ class GameOutcomeRep : public GameObject {
   /// Sets the text label associated with the outcome
   void SetLabel(const std::string &p_label) { m_label = p_label; }
 
-  /// Gets the payoff associated with the outcome to player 'pl'
-  const Number &GetPayoff(int pl) const { return m_payoffs[pl]; }
   /// Gets the payoff associated with the outcome to the player
-  const Number &GetPayoff(const GamePlayer &p_player) const;
-  /// Sets the payoff to player 'pl'
-  void SetPayoff(int pl, const Number &p_value);
+  template <class T> const T &GetPayoff(const GamePlayer &p_player) const;
   /// Sets the payoff to the player
   void SetPayoff(const GamePlayer &p_player, const Number &p_value);
   //@}
@@ -586,27 +582,34 @@ class GameRep : public BaseGameRep {
 // all classes to be defined.
 
 inline Game GameOutcomeRep::GetGame() const { return m_game; }
-inline const Number &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
+
+template <class T> const T &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
 {
-  if (p_player->GetGame() != GetGame()) {
+  try {
+    return static_cast<const T &>(m_payoffs.at(p_player));
+  }
+  catch (const std::out_of_range &) {
     throw MismatchException();
   }
-  return m_payoffs[p_player->GetNumber()];
 }
 
-inline void GameOutcomeRep::SetPayoff(int pl, const Number &p_value)
+template <> inline const Number &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
 {
-  m_game->IncrementVersion();
-  m_payoffs[pl] = p_value;
+  try {
+    return m_payoffs.at(p_player);
+  }
+  catch (const std::out_of_range &) {
+    throw MismatchException();
+  }
 }
 
 inline void GameOutcomeRep::SetPayoff(const GamePlayer &p_player, const Number &p_value)
 {
   if (p_player->GetGame() != GetGame()) {
     throw MismatchException();
   }
+  m_payoffs[p_player] = p_value;
   m_game->IncrementVersion();
-  m_payoffs[p_player->GetNumber()] = p_value;
 }
 
 inline GamePlayer GameStrategyRep::GetPlayer() const { return m_player; }
diff --git a/src/games/gameexpl.cc b/src/games/gameexpl.cc
@@ -66,10 +66,10 @@ Rational GameExplicitRep::GetMinPayoff(int player) const
     p2 = NumPlayers();
   }
 
-  Rational minpay = static_cast<Rational>(m_outcomes.front()->GetPayoff(p1));
+  Rational minpay = m_outcomes.front()->GetPayoff<Rational>(GetPlayer(p1));
   for (auto outcome : m_outcomes) {
     for (int p = p1; p <= p2; p++) {
-      minpay = std::min(minpay, static_cast<Rational>(outcome->GetPayoff(p)));
+      minpay = std::min(minpay, outcome->GetPayoff<Rational>(GetPlayer(p)));
     }
   }
   return minpay;
@@ -91,10 +91,10 @@ Rational GameExplicitRep::GetMaxPayoff(int player) const
     p2 = NumPlayers();
   }
 
-  Rational maxpay = static_cast<Rational>(m_outcomes.front()->GetPayoff(p1));
+  Rational maxpay = m_outcomes.front()->GetPayoff<Rational>(GetPlayer(p1));
   for (auto outcome : m_outcomes) {
     for (int p = p1; p <= p2; p++) {
-      maxpay = std::max(maxpay, static_cast<Rational>(outcome->GetPayoff(p)));
+      maxpay = std::max(maxpay, outcome->GetPayoff<Rational>(GetPlayer(p)));
     }
   }
   return maxpay;
diff --git a/src/games/gametable.cc b/src/games/gametable.cc
@@ -93,7 +93,7 @@ Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) cons
 {
   GameOutcomeRep *outcome = dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index];
   if (outcome) {
-    return static_cast<Rational>(outcome->GetPayoff(p_player));
+    return outcome->GetPayoff<Rational>(p_player);
   }
   else {
     return Rational(0);
@@ -102,13 +102,12 @@ Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) cons
 
 Rational TablePureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_strategy) const
 {
-  int player = p_strategy->GetPlayer()->GetNumber();
+  const auto &player = p_strategy->GetPlayer();
   GameOutcomeRep *outcome =
       dynamic_cast<GameTableRep &>(*m_nfg)
-          .m_results[m_index - m_profile.at(p_strategy->GetPlayer())->m_offset +
-                     p_strategy->m_offset];
+          .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset];
   if (outcome) {
-    return static_cast<Rational>(outcome->GetPayoff(player));
+    return outcome->GetPayoff<Rational>(player);
   }
   else {
     return Rational(0);
@@ -164,7 +163,7 @@ T TableMixedStrategyProfileRep<T>::GetPayoff(int pl, int index, int current) con
     auto &g = dynamic_cast<GameTableRep &>(*game);
     GameOutcomeRep *outcome = g.m_results[index];
     if (outcome) {
-      return static_cast<T>(outcome->GetPayoff(pl));
+      return outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
     else {
       return T(0);
@@ -197,7 +196,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl, int c
     auto &g = dynamic_cast<GameTableRep &>(*game);
     GameOutcomeRep *outcome = g.m_results[index];
     if (outcome) {
-      value += prob * static_cast<T>(outcome->GetPayoff(pl));
+      value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
   }
   else {
@@ -230,7 +229,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl1, int
     auto &g = dynamic_cast<GameTableRep &>(*game);
     GameOutcomeRep *outcome = g.m_results[index];
     if (outcome) {
-      value += prob * static_cast<T>(outcome->GetPayoff(pl));
+      value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
   }
   else {
@@ -371,7 +370,7 @@ void GameTableRep::WriteNfgFile(std::ostream &p_file) const
     p_file << "{ " + QuoteString(outcome->GetLabel()) << ' '
            << FormatList(
                   players,
-                  [outcome](const GamePlayer &p) { return std::string(outcome->GetPayoff(p)); },
+                  [outcome](const GamePlayer &p) { return outcome->GetPayoff<std::string>(p); },
                   true, false)
            << " }" << std::endl;
   }
@@ -393,7 +392,7 @@ GamePlayer GameTableRep::NewPlayer()
   auto player = new GamePlayerRep(this, m_players.size() + 1, 1);
   m_players.push_back(player);
   for (auto outcome : m_outcomes) {
-    outcome->m_payoffs.push_back(Number());
+    outcome->m_payoffs[player] = Number();
   }
   return player;
 }
diff --git a/src/games/gametree.cc b/src/games/gametree.cc
@@ -720,8 +720,8 @@ Rational SubtreeSum(const GameNode &p_node)
   }
 
   if (p_node->GetOutcome()) {
-    for (int pl = 1; pl <= p_node->GetGame()->NumPlayers(); pl++) {
-      sum += static_cast<Rational>(p_node->GetOutcome()->GetPayoff(pl));
+    for (const auto &player : p_node->GetGame()->GetPlayers()) {
+      sum += p_node->GetOutcome()->GetPayoff<Rational>(player);
     }
   }
   return sum;
@@ -916,7 +916,7 @@ void WriteEfgFile(std::ostream &f, const GameNode &n)
     f << n->GetOutcome()->GetNumber() << " " << QuoteString(n->GetOutcome()->GetLabel()) << ' '
       << FormatList(
              n->GetGame()->GetPlayers(),
-             [n](const GamePlayer &p) { return std::string(n->GetOutcome()->GetPayoff(p)); }, true)
+             [n](const GamePlayer &p) { return n->GetOutcome()->GetPayoff<std::string>(p); }, true)
       << std::endl;
   }
   else {
@@ -968,11 +968,10 @@ int GameTreeRep::BehavProfileLength() const
 GamePlayer GameTreeRep::NewPlayer()
 {
   IncrementVersion();
-  GamePlayerRep *player = nullptr;
-  player = new GamePlayerRep(this, m_players.size() + 1);
+  auto player = new GamePlayerRep(this, m_players.size() + 1);
   m_players.push_back(player);
   for (auto &outcome : m_outcomes) {
-    outcome->m_payoffs.push_back(Number());
+    outcome->m_payoffs[player] = Number();
   }
   ClearComputedValues();
   return player;
diff --git a/src/games/nash.cc b/src/games/nash.cc
@@ -103,7 +103,7 @@ template <class T> class SubgameSolution {
     for (const auto &player : p_subroot->GetGame()->GetPlayers()) {
       T value = p_profile.GetPayoff(*subplayer);
       if (outcome) {
-        value += static_cast<T>(outcome->GetPayoff(*subplayer));
+        value += outcome->GetPayoff<T>(*subplayer);
       }
       solution.node_values[p_subroot]->SetPayoff(player, Number(static_cast<Rational>(value)));
       ++subplayer;
diff --git a/src/games/writer.cc b/src/games/writer.cc
@@ -70,7 +70,7 @@ std::string WriteHTMLFile(const Game &p_game, const GamePlayer &p_rowPlayer,
         for (const auto &player : p_game->GetPlayers()) {
           try {
             if (profile->GetOutcome()) {
-              theHtml += static_cast<std::string>(profile->GetOutcome()->GetPayoff(player));
+              theHtml += profile->GetOutcome()->GetPayoff<std::string>(player);
             }
             else {
               theHtml += "0";
@@ -148,7 +148,7 @@ std::string WriteLaTeXFile(const Game &p_game, const GamePlayer &p_rowPlayer,
         for (const auto &player : p_game->GetPlayers()) {
           try {
             if (profile->GetOutcome()) {
-              theHtml += static_cast<std::string>(profile->GetOutcome()->GetPayoff(player));
+              theHtml += profile->GetOutcome()->GetPayoff<std::string>(player);
             }
             else {
               theHtml += "0";
diff --git a/src/gui/dleditnode.cc b/src/gui/dleditnode.cc
@@ -114,10 +114,10 @@ dialogEditNode::dialogEditNode(wxWindow *p_parent, const Gambit::GameNode &p_nod
       item = "Outcome" + Gambit::lexical_cast<std::string>(outc);
     }
 
-    item += (" (" + static_cast<std::string>(outcome->GetPayoff(1)) + ", " +
-             static_cast<std::string>(outcome->GetPayoff(2)));
+    item += (" (" + outcome->GetPayoff<std::string>(efg->GetPlayer(1)) + ", " +
+             outcome->GetPayoff<std::string>(efg->GetPlayer(2)));
     if (efg->NumPlayers() > 2) {
-      item += ", " + static_cast<std::string>(outcome->GetPayoff(3));
+      item += ", " + outcome->GetPayoff<std::string>(efg->GetPlayer(3));
       if (efg->NumPlayers() > 3) {
         item += ",...)";
       }
diff --git a/src/gui/efgdisplay.cc b/src/gui/efgdisplay.cc
@@ -54,8 +54,10 @@ void gbtPayoffEditor::BeginEdit(gbtNodeEntry *p_entry, int p_player)
   m_entry = p_entry;
   m_outcome = p_entry->GetNode()->GetOutcome();
   m_player = p_player;
-  SetValue(
-      wxString(static_cast<std::string>(m_outcome->GetPayoff(p_player)).c_str(), *wxConvCurrent));
+  SetValue(wxString(
+      m_outcome->GetPayoff<std::string>(p_entry->GetNode()->GetGame()->GetPlayer(p_player))
+          .c_str(),
+      *wxConvCurrent));
   SetSize(wxSize(GetSize().GetWidth(), GetBestSize().GetHeight()));
   SetSelection(-1, -1);
   Show(true);
diff --git a/src/gui/efglayout.cc b/src/gui/efglayout.cc
@@ -271,12 +271,12 @@ void gbtNodeEntry::DrawOutcome(wxDC &p_dc, bool p_noHints) const
     Gambit::GamePlayer player = m_node->GetGame()->GetPlayer(pl);
     p_dc.SetTextForeground(m_style->GetPlayerColor(pl));
 
-    std::string payoff = static_cast<std::string>(outcome->GetPayoff(pl));
+    const auto &payoff = outcome->GetPayoff<std::string>(player);
 
     if (payoff.find('/') != std::string::npos) {
       p_dc.SetPen(wxPen(m_style->GetPlayerColor(pl), 1, wxPENSTYLE_SOLID));
       int oldX = point.x;
-      point = DrawFraction(p_dc, point, static_cast<Gambit::Rational>(outcome->GetPayoff(pl)));
+      point = DrawFraction(p_dc, point, outcome->GetPayoff<Rational>(player));
       m_payoffRect.push_back(wxRect(oldX - 5, point.y - height / 2, point.x - oldX + 10, height));
     }
     else {
diff --git a/src/gui/gamedoc.cc b/src/gui/gamedoc.cc
@@ -811,16 +811,16 @@ void gbtGameDocument::DoCopyOutcome(GameNode p_node, GameOutcome p_outcome)
 {
   GameOutcome outcome = m_game->NewOutcome();
   outcome->SetLabel("Outcome" + lexical_cast<std::string>(outcome->GetNumber()));
-  for (int pl = 1; pl <= m_game->NumPlayers(); pl++) {
-    outcome->SetPayoff(pl, p_outcome->GetPayoff(pl));
+  for (const auto &player : m_game->GetPlayers()) {
+    outcome->SetPayoff(player, p_outcome->GetPayoff<Number>(player));
   }
   p_node->SetOutcome(outcome);
   UpdateViews(GBT_DOC_MODIFIED_PAYOFFS);
 }
 
 void gbtGameDocument::DoSetPayoff(GameOutcome p_outcome, int p_player, const wxString &p_value)
 {
-  p_outcome->SetPayoff(p_player, Number(p_value.ToStdString()));
+  p_outcome->SetPayoff(m_game->GetPlayer(p_player), Number(p_value.ToStdString()));
   UpdateViews(GBT_DOC_MODIFIED_PAYOFFS);
 }
 
diff --git a/src/pygambit/gambit.pxd b/src/pygambit/gambit.pxd
@@ -150,7 +150,7 @@ cdef extern from "games/game.h":
         string GetLabel() except +
         void SetLabel(string) except +
 
-        c_Number GetPayoff(c_GamePlayer) except +IndexError
+        T GetPayoff[T](c_GamePlayer) except +IndexError
         void SetPayoff(c_GamePlayer, c_Number) except +IndexError
 
     cdef cppclass c_GameNodeRep "GameNodeRep":
diff --git a/src/pygambit/outcome.pxi b/src/pygambit/outcome.pxi
@@ -85,9 +85,7 @@ class Outcome:
         resolved_player = cython.cast(Player,
                                       self.game._resolve_player(player, "Outcome.__getitem__"))
         payoff = (
-            cython.cast(bytes,
-                        self.outcome.deref().GetPayoff(resolved_player.player).as_string())
-            .decode("ascii")
+            self.outcome.deref().GetPayoff[string](resolved_player.player).decode("ascii")
         )
         if "." in payoff:
             return decimal.Decimal(payoff)
diff --git a/src/solvers/enumpoly/behavextend.cc b/src/solvers/enumpoly/behavextend.cc
@@ -256,7 +256,7 @@ PolynomialSystem<double> NashExpectedPayoffDiffPolys(
             if (NashNodeProbabilityPoly(p_solution, node_prob, BehavStratSpace, support, var_index,
                                         node, infoset, action)) {
               if (node->GetOutcome()) {
-                node_prob *= static_cast<double>(node->GetOutcome()->GetPayoff(player));
+                node_prob *= node->GetOutcome()->GetPayoff<double>(player);
               }
               next_poly += node_prob;
             }
@@ -397,7 +397,7 @@ PolynomialSystem<double> ANFExpectedPayoffDiffPolys(const MixedBehaviorProfile<d
                                      terminal, player->GetNumber(), infoset->GetNumber(),
                                      action->GetNumber())) {
             if (terminal->GetOutcome()) {
-              node_prob *= static_cast<double>(terminal->GetOutcome()->GetPayoff(player));
+              node_prob *= terminal->GetOutcome()->GetPayoff<double>(player);
             }
             next_poly += node_prob;
           }
diff --git a/src/solvers/enumpoly/gameseq.cc b/src/solvers/enumpoly/gameseq.cc
@@ -71,7 +71,7 @@ void GameSequenceForm::FillTableau(const GameNode &n, const Rational &prob,
   if (n->GetOutcome()) {
     for (auto player : m_support.GetGame()->GetPlayers()) {
       GetPayoffEntry(p_currentSequences, player) +=
-          prob * static_cast<Rational>(n->GetOutcome()->GetPayoff(player));
+          prob * n->GetOutcome()->GetPayoff<Rational>(player);
     }
   }
   if (!n->GetInfoset()) {
diff --git a/src/solvers/lcp/efglcp.cc b/src/solvers/lcp/efglcp.cc
@@ -247,10 +247,10 @@ void NashLcpBehaviorSolver<T>::FillTableau(Matrix<T> &A, const GameNode &n, T pr
 
   GameOutcome outcome = n->GetOutcome();
   if (outcome) {
-    A(s1, ns1 + s2) +=
-        Rational(prob) * (static_cast<Rational>(outcome->GetPayoff(1)) - p_solution.maxpay);
-    A(ns1 + s2, s1) +=
-        Rational(prob) * (static_cast<Rational>(outcome->GetPayoff(2)) - p_solution.maxpay);
+    A(s1, ns1 + s2) += Rational(prob) * (outcome->GetPayoff<Rational>(n->GetGame()->GetPlayer(1)) -
+                                         p_solution.maxpay);
+    A(ns1 + s2, s1) += Rational(prob) * (outcome->GetPayoff<Rational>(n->GetGame()->GetPlayer(2)) -
+                                         p_solution.maxpay);
   }
   if (n->IsTerminal()) {
     return;
diff --git a/src/solvers/logit/logbehav.imp b/src/solvers/logit/logbehav.imp
@@ -183,7 +183,7 @@ template <class T> void LogBehavProfile<T>::ComputeSolutionDataPass2(const GameN
   if (node->GetOutcome()) {
     GameOutcome outcome = node->GetOutcome();
     for (auto player : m_game->GetPlayers()) {
-      m_nodeValues[node][player] += static_cast<T>(outcome->GetPayoff(player));
+      m_nodeValues[node][player] += outcome->GetPayoff<T>(player);
     }
   }
 
diff --git a/src/solvers/lp/lp.cc b/src/solvers/lp/lp.cc

Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ void MixedBehaviorProfile<T>::GetPayoff(const GameNode &node, const T &prob,`
`381`	`381`	`const GamePlayer &player, T &value) const`
`382`	`382`	`{`
`383`	`383`	`if (node->GetOutcome()) {`
`384`		`- value += prob * static_cast<T>(node->GetOutcome()->GetPayoff(player));`
	`384`	`+ value += prob * node->GetOutcome()->GetPayoff<T>(player);`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`if (!node->IsTerminal()) {`
`@@ -520,7 +520,7 @@ void MixedBehaviorProfile<T>::ComputePass2_beliefs_nodeValues_actionValues(`
`520`	`520`	`if (node->GetOutcome()) {`
`521`	`521`	`GameOutcome outcome = node->GetOutcome();`
`522`	`522`	`for (auto player : m_support.GetGame()->GetPlayers()) {`
`523`		`- map_nodeValues[node][player] += static_cast<T>(outcome->GetPayoff(player));`
	`523`	`+ map_nodeValues[node][player] += outcome->GetPayoff<T>(player);`
`524`	`524`	`}`
`525`	`525`	`}`
`526`	`526`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ T PureBehaviorProfile::GetPayoff(const GameNode &p_node, const GamePlayer &p_pla`
`49`	`49`	`T payoff(0);`
`50`	`50`
`51`	`51`	`if (p_node->GetOutcome()) {`
`52`		`- payoff += static_cast<T>(p_node->GetOutcome()->GetPayoff(p_player));`
	`52`	`+ payoff += p_node->GetOutcome()->GetPayoff<T>(p_player);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`if (!p_node->IsTerminal()) {`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,11 @@ namespace Gambit {`
`41`	`41`	`// class GameOutcomeRep`
`42`	`42`	`//========================================================================`
`43`	`43`
`44`		`-GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number)`
`45`		`- : m_game(p_game), m_number(p_number), m_payoffs(m_game->NumPlayers())`
	`44`	`+GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number) : m_game(p_game), m_number(p_number)`
`46`	`45`	`{`
	`46`	`+ for (const auto &player : p_game->GetPlayers()) {`
	`47`	`+ m_payoffs[player] = Number();`
	`48`	`+ }`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`//========================================================================`
Original file line number	Diff line number	Diff line change
`@@ -66,10 +66,10 @@ Rational GameExplicitRep::GetMinPayoff(int player) const`
`66`	`66`	`p2 = NumPlayers();`
`67`	`67`	`}`
`68`	`68`
`69`		`- Rational minpay = static_cast<Rational>(m_outcomes.front()->GetPayoff(p1));`
	`69`	`+ Rational minpay = m_outcomes.front()->GetPayoff<Rational>(GetPlayer(p1));`
`70`	`70`	`for (auto outcome : m_outcomes) {`
`71`	`71`	`for (int p = p1; p <= p2; p++) {`
`72`		`- minpay = std::min(minpay, static_cast<Rational>(outcome->GetPayoff(p)));`
	`72`	`+ minpay = std::min(minpay, outcome->GetPayoff<Rational>(GetPlayer(p)));`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`return minpay;`
`@@ -91,10 +91,10 @@ Rational GameExplicitRep::GetMaxPayoff(int player) const`
`91`	`91`	`p2 = NumPlayers();`
`92`	`92`	`}`
`93`	`93`
`94`		`- Rational maxpay = static_cast<Rational>(m_outcomes.front()->GetPayoff(p1));`
	`94`	`+ Rational maxpay = m_outcomes.front()->GetPayoff<Rational>(GetPlayer(p1));`
`95`	`95`	`for (auto outcome : m_outcomes) {`
`96`	`96`	`for (int p = p1; p <= p2; p++) {`
`97`		`- maxpay = std::max(maxpay, static_cast<Rational>(outcome->GetPayoff(p)));`
	`97`	`+ maxpay = std::max(maxpay, outcome->GetPayoff<Rational>(GetPlayer(p)));`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`return maxpay;`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) cons`
`93`	`93`	`{`
`94`	`94`	`GameOutcomeRep outcome = dynamic_cast<GameTableRep &>(m_nfg).m_results[m_index];`
`95`	`95`	`if (outcome) {`
`96`		`- return static_cast<Rational>(outcome->GetPayoff(p_player));`
	`96`	`+ return outcome->GetPayoff<Rational>(p_player);`
`97`	`97`	`}`
`98`	`98`	`else {`
`99`	`99`	`return Rational(0);`
`@@ -102,13 +102,12 @@ Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) cons`
`102`	`102`
`103`	`103`	`Rational TablePureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_strategy) const`
`104`	`104`	`{`
`105`		`- int player = p_strategy->GetPlayer()->GetNumber();`
	`105`	`+ const auto &player = p_strategy->GetPlayer();`
`106`	`106`	`GameOutcomeRep *outcome =`
`107`	`107`	`dynamic_cast<GameTableRep &>(*m_nfg)`
`108`		`- .m_results[m_index - m_profile.at(p_strategy->GetPlayer())->m_offset +`
`109`		`- p_strategy->m_offset];`
	`108`	`+ .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset];`
`110`	`109`	`if (outcome) {`
`111`		`- return static_cast<Rational>(outcome->GetPayoff(player));`
	`110`	`+ return outcome->GetPayoff<Rational>(player);`
`112`	`111`	`}`
`113`	`112`	`else {`
`114`	`113`	`return Rational(0);`
`@@ -164,7 +163,7 @@ T TableMixedStrategyProfileRep<T>::GetPayoff(int pl, int index, int current) con`
`164`	`163`	`auto &g = dynamic_cast<GameTableRep &>(*game);`
`165`	`164`	`GameOutcomeRep *outcome = g.m_results[index];`
`166`	`165`	`if (outcome) {`
`167`		`- return static_cast<T>(outcome->GetPayoff(pl));`
	`166`	`+ return outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));`
`168`	`167`	`}`
`169`	`168`	`else {`
`170`	`169`	`return T(0);`
`@@ -197,7 +196,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl, int c`
`197`	`196`	`auto &g = dynamic_cast<GameTableRep &>(*game);`
`198`	`197`	`GameOutcomeRep *outcome = g.m_results[index];`
`199`	`198`	`if (outcome) {`
`200`		`- value += prob * static_cast<T>(outcome->GetPayoff(pl));`
	`199`	`+ value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));`
`201`	`200`	`}`
`202`	`201`	`}`
`203`	`202`	`else {`
`@@ -230,7 +229,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl1, int`
`230`	`229`	`auto &g = dynamic_cast<GameTableRep &>(*game);`
`231`	`230`	`GameOutcomeRep *outcome = g.m_results[index];`
`232`	`231`	`if (outcome) {`
`233`		`- value += prob * static_cast<T>(outcome->GetPayoff(pl));`
	`232`	`+ value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));`
`234`	`233`	`}`
`235`	`234`	`}`
`236`	`235`	`else {`
`@@ -371,7 +370,7 @@ void GameTableRep::WriteNfgFile(std::ostream &p_file) const`
`371`	`370`	`p_file << "{ " + QuoteString(outcome->GetLabel()) << ' '`
`372`	`371`	`<< FormatList(`
`373`	`372`	`players,`
`374`		`- [outcome](const GamePlayer &p) { return std::string(outcome->GetPayoff(p)); },`
	`373`	`+ [outcome](const GamePlayer &p) { return outcome->GetPayoff<std::string>(p); },`
`375`	`374`	`true, false)`
`376`	`375`	`<< " }" << std::endl;`
`377`	`376`	`}`
`@@ -393,7 +392,7 @@ GamePlayer GameTableRep::NewPlayer()`
`393`	`392`	`auto player = new GamePlayerRep(this, m_players.size() + 1, 1);`
`394`	`393`	`m_players.push_back(player);`
`395`	`394`	`for (auto outcome : m_outcomes) {`
`396`		`- outcome->m_payoffs.push_back(Number());`
	`395`	`+ outcome->m_payoffs[player] = Number();`
`397`	`396`	`}`
`398`	`397`	`return player;`
`399`	`398`	`}`
Original file line number	Diff line number	Diff line change
`@@ -720,8 +720,8 @@ Rational SubtreeSum(const GameNode &p_node)`
`720`	`720`	`}`
`721`	`721`
`722`	`722`	`if (p_node->GetOutcome()) {`
`723`		`- for (int pl = 1; pl <= p_node->GetGame()->NumPlayers(); pl++) {`
`724`		`- sum += static_cast<Rational>(p_node->GetOutcome()->GetPayoff(pl));`
	`723`	`+ for (const auto &player : p_node->GetGame()->GetPlayers()) {`
	`724`	`+ sum += p_node->GetOutcome()->GetPayoff<Rational>(player);`
`725`	`725`	`}`
`726`	`726`	`}`
`727`	`727`	`return sum;`
`@@ -916,7 +916,7 @@ void WriteEfgFile(std::ostream &f, const GameNode &n)`
`916`	`916`	`f << n->GetOutcome()->GetNumber() << " " << QuoteString(n->GetOutcome()->GetLabel()) << ' '`
`917`	`917`	`<< FormatList(`
`918`	`918`	`n->GetGame()->GetPlayers(),`
`919`		`- [n](const GamePlayer &p) { return std::string(n->GetOutcome()->GetPayoff(p)); }, true)`
	`919`	`+ [n](const GamePlayer &p) { return n->GetOutcome()->GetPayoff<std::string>(p); }, true)`
`920`	`920`	`<< std::endl;`
`921`	`921`	`}`
`922`	`922`	`else {`
`@@ -968,11 +968,10 @@ int GameTreeRep::BehavProfileLength() const`
`968`	`968`	`GamePlayer GameTreeRep::NewPlayer()`
`969`	`969`	`{`
`970`	`970`	`IncrementVersion();`
`971`		`- GamePlayerRep *player = nullptr;`
`972`		`- player = new GamePlayerRep(this, m_players.size() + 1);`
	`971`	`+ auto player = new GamePlayerRep(this, m_players.size() + 1);`
`973`	`972`	`m_players.push_back(player);`
`974`	`973`	`for (auto &outcome : m_outcomes) {`
`975`		`- outcome->m_payoffs.push_back(Number());`
	`974`	`+ outcome->m_payoffs[player] = Number();`
`976`	`975`	`}`
`977`	`976`	`ClearComputedValues();`
`978`	`977`	`return player;`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ template <class T> class SubgameSolution {`
`103`	`103`	`for (const auto &player : p_subroot->GetGame()->GetPlayers()) {`
`104`	`104`	`T value = p_profile.GetPayoff(*subplayer);`
`105`	`105`	`if (outcome) {`
`106`		`- value += static_cast<T>(outcome->GetPayoff(*subplayer));`
	`106`	`+ value += outcome->GetPayoff<T>(*subplayer);`
`107`	`107`	`}`
`108`	`108`	`solution.node_values[p_subroot]->SetPayoff(player, Number(static_cast<Rational>(value)));`
`109`	`109`	`++subplayer;`
Original file line number	Diff line number	Diff line change
`@@ -114,10 +114,10 @@ dialogEditNode::dialogEditNode(wxWindow *p_parent, const Gambit::GameNode &p_nod`
`114`	`114`	`item = "Outcome" + Gambit::lexical_cast<std::string>(outc);`
`115`	`115`	`}`
`116`	`116`
`117`		`- item += (" (" + static_cast<std::string>(outcome->GetPayoff(1)) + ", " +`
`118`		`- static_cast<std::string>(outcome->GetPayoff(2)));`
	`117`	`+ item += (" (" + outcome->GetPayoff<std::string>(efg->GetPlayer(1)) + ", " +`
	`118`	`+ outcome->GetPayoff<std::string>(efg->GetPlayer(2)));`
`119`	`119`	`if (efg->NumPlayers() > 2) {`
`120`		`- item += ", " + static_cast<std::string>(outcome->GetPayoff(3));`
	`120`	`+ item += ", " + outcome->GetPayoff<std::string>(efg->GetPlayer(3));`
`121`	`121`	`if (efg->NumPlayers() > 3) {`
`122`	`122`	`item += ",...)";`
`123`	`123`	`}`