Separate implementation of player-specific and overall min/max payoffs.

Closes #497

Author: tturocy

.clang-tidy

@@ -15,7 +15,6 @@ Checks: |
 WarningsAsErrors: '*'
 # Don't bother with wxWidgets headers
 HeaderFilterRegex: '^((?!labenski).)*$'
-AnalyzeTemporaryDtors: false
 FormatStyle:     none
 User:            arbiter
 CheckOptions:

src/games/game.h

@@ -444,10 +444,14 @@ class GameRep : public BaseGameRep {
 
   /// Returns true if the game is constant-sum
   virtual bool IsConstSum() const = 0;
-  /// Returns the smallest payoff in any outcome of the game
-  virtual Rational GetMinPayoff(int pl = 0) const = 0;
-  /// Returns the largest payoff in any outcome of the game
-  virtual Rational GetMaxPayoff(int pl = 0) const = 0;
+  /// Returns the smallest payoff to any player in any outcome of the game
+  virtual Rational GetMinPayoff() const = 0;
+  /// Returns the smallest payoff to the player in any outcome of the game
+  virtual Rational GetMinPayoff(const GamePlayer &p_player) const = 0;
+  /// Returns the largest payoff to any player in any outcome of the game
+  virtual Rational GetMaxPayoff() const = 0;
+  /// Returns the largest payoff to the player in any outcome of the game
+  virtual Rational GetMaxPayoff(const GamePlayer &p_player) const = 0;
 
   /// Returns true if the game is perfect recall.  If not,
   /// a pair of violating information sets is returned in the parameters.

src/games/gameagg.h

@@ -121,11 +121,14 @@ class GameAGGRep : public GameRep {
   bool IsAgg() const override { return true; }
   bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override { return true; }
   bool IsConstSum() const override;
-  /// Returns the smallest payoff in any outcome of the game
-  Rational GetMinPayoff(int) const override { return Rational(aggPtr->getMinPayoff()); }
-  /// Returns the largest payoff in any outcome of the game
-  Rational GetMaxPayoff(int) const override { return Rational(aggPtr->getMaxPayoff()); }
-
+  /// Returns the smallest payoff to any player in any outcome of the game
+  Rational GetMinPayoff() const override { return Rational(aggPtr->getMinPayoff()); }
+  /// Returns the smallest payoff to the player in any outcome of the game
+  Rational GetMinPayoff(const GamePlayer &) const override { throw UndefinedException(); }
+  /// Returns the largest payoff to any player in any outcome of the game
+  Rational GetMaxPayoff() const override { return Rational(aggPtr->getMaxPayoff()); }
+  /// Returns the largest payoff to the player in any outcome of the game
+  Rational GetMaxPayoff(const GamePlayer &) const override { throw UndefinedException(); }
   //@}
 
   /// @name Modification

src/games/gamebagg.h

@@ -122,10 +122,14 @@ class GameBAGGRep : public GameRep {
   virtual bool IsBagg() const { return true; }
   bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override { return true; }
   bool IsConstSum() const override { throw UndefinedException(); }
-  /// Returns the smallest payoff in any outcome of the game
-  Rational GetMinPayoff(int) const override { return Rational(baggPtr->getMinPayoff()); }
-  /// Returns the largest payoff in any outcome of the game
-  Rational GetMaxPayoff(int) const override { return Rational(baggPtr->getMaxPayoff()); }
+  /// Returns the smallest payoff to any player in any outcome of the game
+  Rational GetMinPayoff() const override { return Rational(baggPtr->getMinPayoff()); }
+  /// Returns the smallest payoff to the player in any outcome of the game
+  Rational GetMinPayoff(const GamePlayer &) const override { throw UndefinedException(); }
+  /// Returns the largest payoff to any player in any outcome of the game
+  Rational GetMaxPayoff() const override { return Rational(baggPtr->getMaxPayoff()); }
+  /// Returns the largest payoff to the player in any outcome of the game
+  Rational GetMaxPayoff(const GamePlayer &) const override { throw UndefinedException(); }
   //@}
 
   /// @name Writing data files

src/games/gameexpl.cc

@@ -50,54 +50,42 @@ GameExplicitRep::~GameExplicitRep()
 //                  GameExplicitRep: General data access
 //------------------------------------------------------------------------
 
-Rational GameExplicitRep::GetMinPayoff(int player) const
+Rational GameExplicitRep::GetMinPayoff() const
 {
-  int p1, p2;
+  return std::accumulate(
+      std::next(m_players.begin()), m_players.end(), GetMinPayoff(m_players.front()),
+      [this](const Rational &r, const GamePlayer &p) { return std::min(r, GetMinPayoff(p)); });
+}
 
+Rational GameExplicitRep::GetMinPayoff(const GamePlayer &p_player) const
+{
   if (m_outcomes.empty()) {
     return Rational(0);
   }
-
-  if (player) {
-    p1 = p2 = player;
-  }
-  else {
-    p1 = 1;
-    p2 = NumPlayers();
-  }
-
-  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, outcome->GetPayoff<Rational>(GetPlayer(p)));
-    }
-  }
-  return minpay;
+  return std::accumulate(std::next(m_outcomes.begin()), m_outcomes.end(),
+                         m_outcomes.front()->GetPayoff<Rational>(p_player),
+                         [&p_player](const Rational &r, const GameOutcomeRep *c) {
+                           return std::min(r, c->GetPayoff<Rational>(p_player));
+                         });
 }
 
-Rational GameExplicitRep::GetMaxPayoff(int player) const
+Rational GameExplicitRep::GetMaxPayoff() const
 {
-  int p1, p2;
+  return std::accumulate(
+      std::next(m_players.begin()), m_players.end(), GetMaxPayoff(m_players.front()),
+      [this](const Rational &r, const GamePlayer &p) { return std::max(r, GetMaxPayoff(p)); });
+}
 
+Rational GameExplicitRep::GetMaxPayoff(const GamePlayer &p_player) const
+{
   if (m_outcomes.empty()) {
     return Rational(0);
   }
-
-  if (player) {
-    p1 = p2 = player;
-  }
-  else {
-    p1 = 1;
-    p2 = NumPlayers();
-  }
-
-  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, outcome->GetPayoff<Rational>(GetPlayer(p)));
-    }
-  }
-  return maxpay;
+  return std::accumulate(std::next(m_outcomes.begin()), m_outcomes.end(),
+                         m_outcomes.front()->GetPayoff<Rational>(p_player),
+                         [&p_player](const Rational &r, const GameOutcomeRep *c) {
+                           return std::max(r, c->GetPayoff<Rational>(p_player));
+                         });
 }
 
 //------------------------------------------------------------------------

src/games/gameexpl.h

@@ -43,10 +43,14 @@ class GameExplicitRep : public GameRep {
 
   /// @name General data access
   //@{
-  /// Returns the smallest payoff in any outcome of the game
-  Rational GetMinPayoff(int pl = 0) const override;
-  /// Returns the largest payoff in any outcome of the game
-  Rational GetMaxPayoff(int pl = 0) const override;
+  /// Returns the smallest payoff to any player in any outcome of the game
+  virtual Rational GetMinPayoff() const override;
+  /// Returns the smallest payoff to the player in any outcome of the game
+  virtual Rational GetMinPayoff(const GamePlayer &) const override;
+  /// Returns the largest payoff to any player in any outcome of the game
+  virtual Rational GetMaxPayoff() const override;
+  /// Returns the largest payoff to the player in any outcome of the game
+  virtual Rational GetMaxPayoff(const GamePlayer &) const override;
   //@}
 
   /// @name Dimensions of the game

src/pygambit/gambit.pxd

@@ -218,8 +218,10 @@ cdef extern from "games/game.h":
         int BehavProfileLength() except +
 
         bool IsConstSum() except +
-        c_Rational GetMinPayoff(int) except +
-        c_Rational GetMaxPayoff(int) except +
+        c_Rational GetMinPayoff() except +
+        c_Rational GetMinPayoff(c_GamePlayer) except +
+        c_Rational GetMaxPayoff() except +
+        c_Rational GetMaxPayoff(c_GamePlayer) except +
         bool IsPerfectRecall() except +
 
         c_Game SetChanceProbs(c_GameInfoset, Array[c_Number]) except +

src/pygambit/game.pxi

@@ -704,12 +704,12 @@ class Game:
     @property
     def min_payoff(self) -> typing.Union[decimal.Decimal, Rational]:
         """The minimum payoff in the game."""
-        return rat_to_py(self.game.deref().GetMinPayoff(0))
+        return rat_to_py(self.game.deref().GetMinPayoff())
 
     @property
     def max_payoff(self) -> typing.Union[decimal.Decimal, Rational]:
         """The maximum payoff in the game."""
-        return rat_to_py(self.game.deref().GetMaxPayoff(0))
+        return rat_to_py(self.game.deref().GetMaxPayoff())
 
     def set_chance_probs(self, infoset: typing.Union[Infoset, str], probs: typing.Sequence):
         """Set the action probabilities at chance information set `infoset`.

src/pygambit/player.pxi

@@ -227,9 +227,9 @@ class Player:
     @property
     def min_payoff(self) -> Rational:
         """Returns the smallest payoff for the player in any outcome of the game."""
-        return rat_to_py(self.player.deref().GetGame().deref().GetMinPayoff(self.number + 1))
+        return rat_to_py(self.player.deref().GetGame().deref().GetMinPayoff(self.player))
 
     @property
     def max_payoff(self) -> Rational:
         """Returns the largest payoff for the player in any outcome of the game."""
-        return rat_to_py(self.player.deref().GetGame().deref().GetMaxPayoff(self.number + 1))
+        return rat_to_py(self.player.deref().GetGame().deref().GetMaxPayoff(self.player))