Implement collection classes for games.

This implements a new template class, ElementCollection, which represents
a collection of objects in a game.  This handles efficient access
and iteration over game objects without the need to allocate a new container.

Closes #516

Author: tturocy

src/games/behavmixed.cc

@@ -465,29 +465,25 @@ T MixedBehaviorProfile<T>::DiffNodeValue(const GameNode &p_node, const GamePlaye
   CheckVersion();
   ComputeSolutionData();
 
-  if (p_node->NumChildren() > 0) {
-    const GameInfoset infoset = p_node->GetInfoset();
-
-    if (infoset == p_oppAction->GetInfoset()) {
-      // We've encountered the action; since we assume perfect recall,
-      // we won't encounter it again, and the downtree value must
-      // be the same.
-      return map_nodeValues[p_node->GetChild(p_oppAction)][p_player];
-    }
-    else {
-      T deriv = T(0);
-      for (auto action : infoset->GetActions()) {
-        deriv += (DiffNodeValue(p_node->GetChild(action), p_player, p_oppAction) *
-                  GetActionProb(action));
-      }
-      return deriv;
-    }
-  }
-  else {
+  if (p_node->IsTerminal()) {
     // If we reach a terminal node and haven't encountered p_oppAction,
     // derivative wrt this path is zero.
     return T(0);
   }
+  if (p_node->GetInfoset() == p_oppAction->GetInfoset()) {
+    // We've encountered the action; since we assume perfect recall,
+    // we won't encounter it again, and the downtree value must
+    // be the same.
+    return map_nodeValues[p_node->GetChild(p_oppAction)][p_player];
+  }
+  else {
+    T deriv = T(0);
+    for (auto action : p_node->GetInfoset()->GetActions()) {
+      deriv +=
+          (DiffNodeValue(p_node->GetChild(action), p_player, p_oppAction) * GetActionProb(action));
+    }
+    return deriv;
+  }
 }
 
 //========================================================================

src/games/behavmixed.h

@@ -244,7 +244,8 @@ MixedBehaviorProfile<Rational> GameRep::NewRandomBehaviorProfile(int p_denom,
   auto profile = MixedBehaviorProfile<Rational>(Game(const_cast<GameRep *>(this)));
   for (auto player : GetPlayers()) {
     for (auto infoset : player->GetInfosets()) {
-      std::list<Rational> dist = UniformOnSimplex(p_denom, infoset->NumActions(), generator);
+      std::list<Rational> dist =
+          UniformOnSimplex(p_denom, infoset->GetActions().size(), generator);
       auto prob = dist.cbegin();
       for (auto action : infoset->GetActions()) {
         profile[action] = *prob;

src/games/file.cc

@@ -428,7 +428,7 @@ void ParsePayoffBody(GameFileLexer &p_parser, Game &p_nfg)
 {
   const StrategySupportProfile profile(p_nfg);
   for (auto iter : StrategyContingencies(profile)) {
-    for (auto player : p_nfg->GetPlayers()) {
+    for (const auto &player : p_nfg->GetPlayers()) {
       p_parser.ExpectCurrentToken(TOKEN_NUMBER, "numerical payoff");
       iter->GetOutcome()->SetPayoff(player, Number(p_parser.GetLastText()));
       p_parser.GetNextToken();

src/games/game.cc

@@ -41,7 +41,7 @@ namespace Gambit {
 
 GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number) : m_game(p_game), m_number(p_number)
 {
-  for (const auto &player : p_game->GetPlayers()) {
+  for (const auto &player : m_game->m_players) {
     m_payoffs[player] = Number();
   }
 }
@@ -68,20 +68,11 @@ GamePlayerRep::~GamePlayerRep()
   }
 }
 
-Array<GameStrategy> GamePlayerRep::GetStrategies() const
-{
-  m_game->BuildComputedValues();
-  Array<GameStrategy> ret(m_strategies.size());
-  std::transform(m_strategies.cbegin(), m_strategies.cend(), ret.begin(),
-                 [](const GameStrategyRep *s) -> GameStrategy { return s; });
-  return ret;
-}
-
 void GamePlayerRep::MakeStrategy()
 {
-  Array<int> c(NumInfosets());
+  Array<int> c(m_infosets.size());
 
-  for (size_t i = 1; i <= NumInfosets(); i++) {
+  for (size_t i = 1; i <= m_infosets.size(); i++) {
     if (m_infosets[i - 1]->flag == 1) {
       c[i] = m_infosets[i - 1]->whichbranch;
     }
@@ -118,12 +109,12 @@ void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
     n->ptr = nullptr;
   }
 
-  if (n->NumChildren() > 0) {
+  if (!n->IsTerminal()) {
     if (n->m_infoset->m_player == this) {
       if (n->m_infoset->flag == 0) {
         // we haven't visited this infoset before
         n->m_infoset->flag = 1;
-        for (size_t i = 1; i <= n->NumChildren(); i++) {
+        for (size_t i = 1; i <= n->m_children.size(); i++) {
           GameNodeRep *m = n->m_children[i - 1];
           n->whichbranch = m;
           n->m_infoset->whichbranch = i;
@@ -175,52 +166,19 @@ void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
   }
 }
 
-GameInfoset GamePlayerRep::GetInfoset(int p_index) const { return m_infosets[p_index - 1]; }
-
-Array<GameInfoset> GamePlayerRep::GetInfosets() const
-{
-  Array<GameInfoset> ret(m_infosets.size());
-  std::transform(m_infosets.cbegin(), m_infosets.cend(), ret.begin(),
-                 [](const GameInfosetRep *s) -> GameInfoset { return s; });
-  return ret;
-}
-
 size_t GamePlayerRep::NumSequences() const
 {
   if (!m_game->IsTree()) {
     throw UndefinedException();
   }
-  return std::accumulate(
-      m_infosets.cbegin(), m_infosets.cend(), 1,
-      [](int ct, const GameInfosetRep *s) -> int { return ct + s->m_actions.size(); });
+  return std::transform_reduce(m_infosets.cbegin(), m_infosets.cend(), 1, std::plus<>(),
+                               [](const GameInfosetRep *s) { return s->m_actions.size(); });
 }
 
 //========================================================================
 //                            class GameRep
 //========================================================================
 
-Array<GamePlayer> GameRep::GetPlayers() const
-{
-  Array<GamePlayer> ret(NumPlayers());
-  for (size_t pl = 1; pl <= NumPlayers(); pl++) {
-    ret[pl] = GetPlayer(pl);
-  }
-  return ret;
-}
-
-Array<GameStrategy> GameRep::GetStrategies() const
-{
-  Array<GameStrategy> ret(MixedProfileLength());
-  auto output = ret.begin();
-  for (auto player : GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      *output = strategy;
-      ++output;
-    }
-  }
-  return ret;
-}
-
 GameRep::~GameRep()
 {
   for (auto player : m_players) {