Store results in a std::vector

Author: tturocy

src/games/gametable.cc

@@ -81,17 +81,17 @@ void TablePureStrategyProfileRep::SetStrategy(const GameStrategy &s)
 
 GameOutcome TablePureStrategyProfileRep::GetOutcome() const
 {
-  return dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index];
+  return dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index - 1];
 }
 
 void TablePureStrategyProfileRep::SetOutcome(GameOutcome p_outcome)
 {
-  dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index] = p_outcome;
+  dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index - 1] = p_outcome;
 }
 
 Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) const
 {
-  GameOutcomeRep *outcome = dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index];
+  GameOutcomeRep *outcome = dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index - 1];
   if (outcome) {
     return outcome->GetPayoff<Rational>(p_player);
   }
@@ -105,7 +105,7 @@ Rational TablePureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_str
   const auto &player = p_strategy->GetPlayer();
   GameOutcomeRep *outcome =
       dynamic_cast<GameTableRep &>(*m_nfg)
-          .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset];
+          .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset - 1];
   if (outcome) {
     return outcome->GetPayoff<Rational>(player);
   }
@@ -161,7 +161,7 @@ T TableMixedStrategyProfileRep<T>::GetPayoff(int pl, int index, int current) con
   if (current > static_cast<int>(this->m_support.GetGame()->NumPlayers())) {
     const Game game = this->m_support.GetGame();
     auto &g = dynamic_cast<GameTableRep &>(*game);
-    GameOutcomeRep *outcome = g.m_results[index];
+    GameOutcomeRep *outcome = g.m_results[index - 1];
     if (outcome) {
       return outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
@@ -194,7 +194,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl, int c
   if (cur_pl > static_cast<int>(this->m_support.GetGame()->NumPlayers())) {
     const Game game = this->m_support.GetGame();
     auto &g = dynamic_cast<GameTableRep &>(*game);
-    GameOutcomeRep *outcome = g.m_results[index];
+    GameOutcomeRep *outcome = g.m_results[index - 1];
     if (outcome) {
       value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
@@ -227,7 +227,7 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl1, int
   if (cur_pl > static_cast<int>(this->m_support.GetGame()->NumPlayers())) {
     const Game game = this->m_support.GetGame();
     auto &g = dynamic_cast<GameTableRep &>(*game);
-    GameOutcomeRep *outcome = g.m_results[index];
+    GameOutcomeRep *outcome = g.m_results[index - 1];
     if (outcome) {
       value += prob * outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
@@ -265,23 +265,9 @@ template class TableMixedStrategyProfileRep<Rational>;
 //                     GameTableRep: Lifecycle
 //------------------------------------------------------------------------
 
-namespace {
-/// This convenience function computes the Cartesian product of the
-/// elements in dim.
-int Product(const Array<int> &dim)
-{
-  int accum = 1;
-  for (auto d : dim) {
-    accum *= d;
-  }
-  return accum;
-}
-
-} // end anonymous namespace
-
 GameTableRep::GameTableRep(const Array<int> &dim, bool p_sparseOutcomes /* = false */)
+  : m_results(std::accumulate(dim.begin(), dim.end(), 1, std::multiplies<>()))
 {
-  m_results = Array<GameOutcomeRep *>(Product(dim));
   for (size_t pl = 1; pl <= dim.size(); pl++) {
     m_players.push_back(new GamePlayerRep(this, pl, dim[pl]));
     m_players.back()->m_label = lexical_cast<std::string>(pl);
@@ -488,7 +474,7 @@ void GameTableRep::RebuildTable()
     size *= player->m_strategies.size();
   }
 
-  Array<GameOutcomeRep *> newResults(size);
+  std::vector<GameOutcomeRep *> newResults(size);
   std::fill(newResults.begin(), newResults.end(), nullptr);
 
   for (auto iter :
@@ -501,17 +487,15 @@ void GameTableRep::RebuildTable()
         break;
       }
       else {
-        newindex += (iter->GetStrategy(player)->m_number - 1) * offsets[player->GetNumber()];
+        newindex += (iter->GetStrategy(player)->m_number - 1) * offsets[player->m_number];
       }
     }
 
     if (newindex >= 1) {
-      newResults[newindex] = iter->GetOutcome();
+      newResults[newindex - 1] = iter->GetOutcome();
     }
   }
-
   m_results = newResults;
-
   IndexStrategies();
 }
 

src/games/gametable.h

@@ -36,7 +36,7 @@ class GameTableRep : public GameExplicitRep {
   template <class T> friend class TableMixedStrategyProfileRep;
 
 private:
-  Array<GameOutcomeRep *> m_results;
+  std::vector<GameOutcomeRep *> m_results;
 
   /// @name Private auxiliary functions
   //@{