Merge branch 'master' into integrate_llm

# Conflicts:
#	src/games/game.h
#	src/games/gametree.h

Author: tturocy

src/games/behavmixed.cc

@@ -115,7 +115,7 @@ void MixedBehaviorProfile<T>::RealizationProbs(const MixedStrategyProfile<T> &mp
       prob = T(node->m_infoset->GetActionProb(node->m_infoset->GetAction(i)));
     }
 
-    GameNodeRep *child = node->m_children[i];
+    GameNodeRep *child = node->m_children[i - 1];
 
     map_bvals[child] = prob * map_bvals[node];
     map_nvals[child] += map_bvals[child];
@@ -428,8 +428,8 @@ T MixedBehaviorProfile<T>::DiffActionValue(const GameAction &p_action,
 
     deriv += DiffRealizProb(member, p_oppAction) *
              (map_nodeValues[child][player] - map_actionValues[p_action]);
-    deriv += map_realizProbs[member] *
-             DiffNodeValue(member->GetChild(p_action->GetNumber()), player, p_oppAction);
+    deriv +=
+        map_realizProbs[member] * DiffNodeValue(member->GetChild(p_action), player, p_oppAction);
   }
 
   return deriv / GetInfosetProb(p_action->GetInfoset());
@@ -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

@@ -304,9 +304,9 @@ class TableFileGame {
   std::vector<TableFilePlayer> m_players;
 
   size_t NumPlayers() const { return m_players.size(); }
-  Array<int> NumStrategies() const
+  std::vector<int> NumStrategies() const
   {
-    Array<int> ret(m_players.size());
+    std::vector<int> ret(m_players.size());
     std::transform(m_players.begin(), m_players.end(), ret.begin(),
                    [](const TableFilePlayer &player) { return player.m_strategies.size(); });
     return ret;
@@ -426,7 +426,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,13 +109,13 @@ 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++) {
-          GameNodeRep *m = n->m_children[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;
           MakeReducedStrats(m, nn);
@@ -133,19 +124,19 @@ void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
       }
       else {
         // we have visited this infoset, take same action
-        MakeReducedStrats(n->m_children[n->m_infoset->whichbranch], nn);
+        MakeReducedStrats(n->m_children[n->m_infoset->whichbranch - 1], nn);
       }
     }
     else {
       n->ptr = nullptr;
       if (nn != nullptr) {
         n->ptr = nn->m_parent;
       }
-      n->whichbranch = n->m_children[1];
+      n->whichbranch = n->m_children.front();
       if (n->m_infoset) {
         n->m_infoset->whichbranch = 0;
       }
-      MakeReducedStrats(n->m_children[1], n->m_children[1]);
+      MakeReducedStrats(n->m_children.front(), n->m_children.front());
     }
   }
   else if (nn) {
@@ -175,50 +166,27 @@ 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
+GameRep::~GameRep()
 {
-  Array<GamePlayer> ret(NumPlayers());
-  for (size_t pl = 1; pl <= NumPlayers(); pl++) {
-    ret[pl] = GetPlayer(pl);
+  for (auto player : m_players) {
+    player->Invalidate();
   }
-  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;
-    }
+  for (auto outcome : m_outcomes) {
+    outcome->Invalidate();
   }
-  return ret;
 }
 
 //------------------------------------------------------------------------