Implement StrategySupportProfile as vectors of legal "digits" in indexing the Cartesian product space.

Author: tturocy

src/games/behavmixed.cc

@@ -252,6 +252,7 @@ template <class T> MixedBehaviorProfile<T> MixedBehaviorProfile<T>::ToFullSuppor
 
 template <class T> T MixedBehaviorProfile<T>::GetLiapValue() const
 {
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this).GetLiapValue();
 }
 
@@ -356,6 +357,7 @@ template <class T> T MixedBehaviorProfile<T>::GetRegret(const GameInfoset &p_inf
 
 template <class T> T MixedBehaviorProfile<T>::GetMaxRegret() const
 {
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this).GetMaxRegret();
 }
 
@@ -553,6 +555,7 @@ template <class T> bool MixedBehaviorProfile<T>::IsDefinedAt(GameInfoset p_infos
 template <class T> MixedStrategyProfile<T> MixedBehaviorProfile<T>::ToMixedProfile() const
 {
   CheckVersion();
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this);
 }
 

src/games/game.h

@@ -600,6 +600,12 @@ class CartesianProductSpace {
   std::vector<long> m_strides;
 };
 
+class CartesianSubset {
+public:
+  const CartesianProductSpace *m_space;
+  std::vector<std::vector<int>> m_allowedDigits;
+};
+
 template <class T> class CartesianTensor {
 public:
   const CartesianProductSpace *m_space;
@@ -614,6 +620,7 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   friend class GamePlayerRep;
   friend class PureStrategyProfileRep;
   friend class TablePureStrategyProfileRep;
+  friend class StrategySupportProfile;
   template <class T> friend class MixedBehaviorProfile;
   template <class T> friend class MixedStrategyProfile;
   template <class T> friend class TableMixedStrategyProfileRep;

src/games/gametree.cc

@@ -1356,7 +1356,7 @@ MixedStrategyProfile<double> GameTreeRep::NewMixedStrategyProfile(double) const
   if (!IsPerfectRecall()) {
     throw UndefinedException("Mixed strategies not supported for games with imperfect recall.");
   }
-  EnsureInfosetOrdering();
+  BuildComputedValues();
   return StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))
       .NewMixedStrategyProfile<double>();
 }
@@ -1366,7 +1366,7 @@ MixedStrategyProfile<Rational> GameTreeRep::NewMixedStrategyProfile(const Ration
   if (!IsPerfectRecall()) {
     throw UndefinedException("Mixed strategies not supported for games with imperfect recall.");
   }
-  EnsureInfosetOrdering();
+  BuildComputedValues();
   return StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))
       .NewMixedStrategyProfile<Rational>();
 }
@@ -1377,7 +1377,7 @@ GameTreeRep::NewMixedStrategyProfile(double, const StrategySupportProfile &spt)
   if (!IsPerfectRecall()) {
     throw UndefinedException("Mixed strategies not supported for games with imperfect recall.");
   }
-  EnsureInfosetOrdering();
+  BuildComputedValues();
   return MixedStrategyProfile<double>(std::make_unique<TreeMixedStrategyProfileRep<double>>(spt));
 }
 
@@ -1387,7 +1387,7 @@ GameTreeRep::NewMixedStrategyProfile(const Rational &, const StrategySupportProf
   if (!IsPerfectRecall()) {
     throw UndefinedException("Mixed strategies not supported for games with imperfect recall.");
   }
-  EnsureInfosetOrdering();
+  BuildComputedValues();
   return MixedStrategyProfile<Rational>(
       std::make_unique<TreeMixedStrategyProfileRep<Rational>>(spt));
 }
@@ -1417,7 +1417,7 @@ class TreePureStrategyProfileRep : public PureStrategyProfileRep {
 
 PureStrategyProfile GameTreeRep::NewPureStrategyProfile() const
 {
-  EnsureInfosetOrdering();
+  BuildComputedValues();
   return PureStrategyProfile(std::make_shared<TreePureStrategyProfileRep>(
       std::const_pointer_cast<GameRep>(shared_from_this())));
 }

src/games/stratspt.cc

@@ -32,51 +32,48 @@ namespace Gambit {
 //                        class StrategySupportProfile
 //===========================================================================
 
-StrategySupportProfile::StrategySupportProfile(const Game &p_nfg) : m_nfg(p_nfg)
+StrategySupportProfile::StrategySupportProfile(const Game &p_game) : m_game(p_game)
 {
-  for (auto player : m_nfg->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      m_support[player].push_back(strategy);
-    }
+  m_game->BuildComputedValues();
+  m_strategies.m_space = &p_game->m_pureStrategies;
+  m_strategies.m_allowedDigits.resize(p_game->NumPlayers());
+
+  for (size_t i = 0; i < p_game->NumPlayers(); ++i) {
+    const int radix = p_game->m_pureStrategies.m_radices[i];
+    auto &digits = m_strategies.m_allowedDigits[i];
+    digits.resize(radix);
+    std::iota(digits.begin(), digits.end(), 0);
   }
 }
 
-Array<int> StrategySupportProfile::NumStrategies() const
-{
-  Array<int> dim(m_support.size());
-  std::transform(
-      m_support.cbegin(), m_support.cend(), dim.begin(),
-      [](std::pair<GamePlayer, std::vector<GameStrategy>> a) { return a.second.size(); });
-  return dim;
-}
-
 int StrategySupportProfile::MixedProfileLength() const
 {
-  return std::accumulate(m_support.cbegin(), m_support.cend(), 0,
-                         [](size_t tot, std::pair<GamePlayer, std::vector<GameStrategy>> a) {
-                           return tot + a.second.size();
-                         });
+  return sum_function(m_strategies.m_allowedDigits, [](const std::vector<int> &digits) {
+    return static_cast<int>(digits.size());
+  });
 }
 
 template <> MixedStrategyProfile<double> StrategySupportProfile::NewMixedStrategyProfile() const
 {
-  return m_nfg->NewMixedStrategyProfile(0.0, *this);
+  return m_game->NewMixedStrategyProfile(0.0, *this);
 }
 
 template <> MixedStrategyProfile<Rational> StrategySupportProfile::NewMixedStrategyProfile() const
 {
-  return m_nfg->NewMixedStrategyProfile(Rational(0), *this);
+  return m_game->NewMixedStrategyProfile(Rational(0), *this);
 }
 
-bool StrategySupportProfile::IsSubsetOf(const StrategySupportProfile &p_support) const
+bool StrategySupportProfile::IsSubsetOf(const StrategySupportProfile &p_other) const
 {
-  for (auto player : m_nfg->GetPlayers()) {
-    if (!std::includes(p_support.m_support.at(player).begin(),
-                       p_support.m_support.at(player).end(), m_support.at(player).begin(),
-                       m_support.at(player).end(),
-                       [](const GameStrategy &s, const GameStrategy &t) {
-                         return s->GetNumber() < t->GetNumber();
-                       })) {
+  if (m_game != p_other.m_game) {
+    return false;
+  }
+  const auto &A = m_strategies.m_allowedDigits;
+  const auto &B = p_other.m_strategies.m_allowedDigits;
+  const size_t n = A.size();
+
+  for (size_t i = 0; i < n; ++i) {
+    if (!std::includes(B[i].begin(), B[i].end(), A[i].begin(), A[i].end())) {
       return false;
     }
   }
@@ -85,8 +82,8 @@ bool StrategySupportProfile::IsSubsetOf(const StrategySupportProfile &p_support)
 
 void StrategySupportProfile::WriteNfgFile(std::ostream &p_file) const
 {
-  auto players = m_nfg->GetPlayers();
-  p_file << "NFG 1 R " << std::quoted(m_nfg->GetTitle()) << ' '
+  auto players = m_game->GetPlayers();
+  p_file << "NFG 1 R " << std::quoted(m_game->GetTitle()) << ' '
          << FormatList(players, [](const GamePlayer &p) { return QuoteString(p->GetLabel()); })
          << std::endl
          << std::endl;
@@ -97,7 +94,7 @@ void StrategySupportProfile::WriteNfgFile(std::ostream &p_file) const
     }) << std::endl;
   }
   p_file << "}" << std::endl;
-  p_file << std::quoted(m_nfg->GetComment()) << std::endl << std::endl;
+  p_file << std::quoted(m_game->GetComment()) << std::endl << std::endl;
 
   for (auto iter : StrategyContingencies(*this)) {
     p_file << FormatList(
@@ -112,25 +109,32 @@ void StrategySupportProfile::WriteNfgFile(std::ostream &p_file) const
 
 void StrategySupportProfile::AddStrategy(const GameStrategy &p_strategy)
 {
-  auto &support = m_support[p_strategy->GetPlayer()];
-  auto pos = std::find_if(support.begin(), support.end(), [p_strategy](const GameStrategy &s) {
-    return s->GetNumber() >= p_strategy->GetNumber();
-  });
-  if (pos == support.end() || *pos != p_strategy) {
-    // Strategy is not in the support for the player; add at this location to keep sorted by number
-    support.insert(pos, p_strategy);
+  if (p_strategy->GetGame() != m_game) {
+    throw MismatchException();
+  }
+  const size_t index = p_strategy->GetPlayer()->GetNumber() - 1;
+  const int digit = p_strategy->GetNumber() - 1;
+  auto &digits = m_strategies.m_allowedDigits[index];
+  auto pos = std::lower_bound(digits.begin(), digits.end(), digit);
+  if (pos == digits.end() || *pos != digit) {
+    digits.insert(pos, digit);
   }
 }
 
 bool StrategySupportProfile::RemoveStrategy(const GameStrategy &p_strategy)
 {
-  auto &support = m_support[p_strategy->GetPlayer()];
-  if (support.size() == 1) {
+  if (p_strategy->GetGame() != m_game) {
+    throw MismatchException();
+  }
+  const size_t index = p_strategy->GetPlayer()->GetNumber() - 1;
+  const int digit = p_strategy->GetNumber() - 1;
+  auto &digits = m_strategies.m_allowedDigits[index];
+  if (digits.size() == 1) {
     return false;
   }
-  auto pos = std::find(support.begin(), support.end(), p_strategy);
-  if (pos != support.end()) {
-    support.erase(pos);
+  auto pos = std::lower_bound(digits.begin(), digits.end(), digit);
+  if (pos != digits.end() && *pos == digit) {
+    digits.erase(pos);
     return true;
   }
   return false;
@@ -263,7 +267,7 @@ bool UndominatedForPlayer(const StrategySupportProfile &p_support,
 StrategySupportProfile StrategySupportProfile::Undominated(bool p_strict, bool p_external) const
 {
   StrategySupportProfile newSupport(*this);
-  for (auto player : m_nfg->GetPlayers()) {
+  for (auto player : m_game->GetPlayers()) {
     UndominatedForPlayer(*this, newSupport, player, p_strict, p_external);
   }
   return newSupport;

src/games/stratspt.h

@@ -39,31 +39,83 @@ namespace Gambit {
 /// Within the support, strategies are maintained in the same order
 /// in which they appear in the underlying game.
 class StrategySupportProfile {
-protected:
-  Game m_nfg;
-  std::map<GamePlayer, std::vector<GameStrategy>> m_support;
+  Game m_game;
+  CartesianSubset m_strategies;
 
 public:
   class Support {
-  private:
     const StrategySupportProfile *m_profile;
-    GamePlayer m_player;
+    size_t m_playerIndex;
 
   public:
-    using const_iterator = std::vector<GameStrategy>::const_iterator;
+    class const_iterator {
+      const StrategySupportProfile *m_profile{nullptr};
+      size_t m_playerIndex{0};
+      std::vector<int>::const_iterator m_it;
+
+    public:
+      using value_type = GameStrategy;
+      using reference = GameStrategy;
+      using pointer = void;
+      using difference_type = std::ptrdiff_t;
+      using iterator_category = std::forward_iterator_tag;
+
+      const_iterator() = default;
+      const_iterator(const StrategySupportProfile *profile, const size_t playerIndex,
+                     const std::vector<int>::const_iterator it)
+        : m_profile(profile), m_playerIndex(playerIndex), m_it(it)
+      {
+      }
+
+      GameStrategy operator*() const
+      {
+        const auto &player = m_profile->m_game->GetPlayer(m_playerIndex + 1);
+        return player->GetStrategy(*m_it + 1);
+      }
+
+      const_iterator &operator++()
+      {
+        ++m_it;
+        return *this;
+      }
+
+      bool operator==(const const_iterator &other) const { return m_it == other.m_it; }
+
+      bool operator!=(const const_iterator &other) const { return !(*this == other); }
+    };
+
+    Support() : m_profile(nullptr), m_playerIndex(0) {}
+
+    Support(const StrategySupportProfile *profile, GamePlayer player)
+      : m_profile(profile), m_playerIndex(player->GetNumber() - 1)
+    {
+    }
 
-    Support() : m_profile(nullptr), m_player(nullptr) {}
-    Support(const StrategySupportProfile *p_profile, GamePlayer p_player)
-      : m_profile(p_profile), m_player(p_player)
+    size_t size() const { return m_profile->m_strategies.m_allowedDigits[m_playerIndex].size(); }
+
+    GameStrategy front() const
     {
+      const int digit = m_profile->m_strategies.m_allowedDigits[m_playerIndex].front();
+      return m_profile->m_game->GetPlayer(m_playerIndex + 1)->GetStrategy(digit + 1);
     }
 
-    size_t size() const { return m_profile->m_support.at(m_player).size(); }
-    GameStrategy front() const { return m_profile->m_support.at(m_player).front(); }
-    GameStrategy back() const { return m_profile->m_support.at(m_player).back(); }
+    GameStrategy back() const
+    {
+      const int digit = m_profile->m_strategies.m_allowedDigits[m_playerIndex].back();
+      return m_profile->m_game->GetPlayer(m_playerIndex + 1)->GetStrategy(digit + 1);
+    }
 
-    const_iterator begin() const { return m_profile->m_support.at(m_player).begin(); }
-    const_iterator end() const { return m_profile->m_support.at(m_player).end(); }
+    const_iterator begin() const
+    {
+      const auto &digits = m_profile->m_strategies.m_allowedDigits[m_playerIndex];
+      return {m_profile, m_playerIndex, digits.begin()};
+    }
+
+    const_iterator end() const
+    {
+      const auto &digits = m_profile->m_strategies.m_allowedDigits[m_playerIndex];
+      return {m_profile, m_playerIndex, digits.end()};
+    }
   };
 
   /// @name Lifecycle
@@ -77,37 +129,41 @@ class StrategySupportProfile {
   /// Test for the equality of two supports (same strategies for all players)
   bool operator==(const StrategySupportProfile &p_support) const
   {
-    return (m_support == p_support.m_support);
+    return m_game == p_support.m_game &&
+           m_strategies.m_allowedDigits == p_support.m_strategies.m_allowedDigits;
   }
   /// Test for the inequality of two supports
   bool operator!=(const StrategySupportProfile &p_support) const
   {
-    return (m_support != p_support.m_support);
+    return m_game != p_support.m_game ||
+           m_strategies.m_allowedDigits != p_support.m_strategies.m_allowedDigits;
   }
   //@}
 
   /// @name General information
   //@{
   /// Returns the game on which the support is defined.
-  Game GetGame() const { return m_nfg; }
-
-  /// Returns the number of strategies in the support for all players.
-  Array<int> NumStrategies() const;
+  Game GetGame() const { return m_game; }
 
   /// Returns the total number of strategies in the support.
   int MixedProfileLength() const;
 
   template <class T> MixedStrategyProfile<T> NewMixedStrategyProfile() const;
 
   /// Returns the number of players in the game
-  int NumPlayers() const { return m_nfg->NumPlayers(); }
+  int NumPlayers() const { return m_game->NumPlayers(); }
   /// Returns the set of players in the game
-  GameRep::Players GetPlayers() const { return m_nfg->GetPlayers(); }
+  GameRep::Players GetPlayers() const { return m_game->GetPlayers(); }
   /// Returns the set of strategies in the support for a player
   Support GetStrategies(const GamePlayer &p_player) const { return {this, p_player}; }
 
   /// Returns true exactly when the strategy is in the support.
-  bool Contains(const GameStrategy &s) const { return contains(m_support.at(s->GetPlayer()), s); }
+  bool Contains(const GameStrategy &s) const
+  {
+    const auto &digits = m_strategies.m_allowedDigits[s->GetPlayer()->GetNumber() - 1];
+    const int digit = s->GetNumber() - 1;
+    return std::binary_search(digits.begin(), digits.end(), digit);
+  }
 
   /// Returns true iff this support is a (weak) subset of the specified support
   bool IsSubsetOf(const StrategySupportProfile &) const;