Store results in GameTableRep in a std::vector instead of Array

Author: tturocy

src/games/gametable.cc

@@ -34,7 +34,7 @@ namespace Gambit {
 
 class TablePureStrategyProfileRep : public PureStrategyProfileRep {
 protected:
-  long m_index{1L};
+  long m_index{0L};
 
   std::shared_ptr<PureStrategyProfileRep> Copy() const override;
 
@@ -166,13 +166,13 @@ T TableMixedStrategyProfileRep<T>::GetPayoff(int pl, int index, int current) con
       return outcome->GetPayoff<T>(this->m_support.GetGame()->GetPlayer(pl));
     }
     else {
-      return T(0);
+      return static_cast<T>(0);
     }
   }
 
   T sum = static_cast<T>(0);
   for (auto s : this->m_support.GetStrategies(this->m_support.GetGame()->GetPlayer(current))) {
-    if ((*this)[s] != T(0)) {
+    if ((*this)[s] != static_cast<T>(0)) {
       sum += ((*this)[s] * GetPayoff(pl, index + s->m_offset, current + 1));
     }
   }
@@ -181,7 +181,7 @@ T TableMixedStrategyProfileRep<T>::GetPayoff(int pl, int index, int current) con
 
 template <class T> T TableMixedStrategyProfileRep<T>::GetPayoff(int pl) const
 {
-  return GetPayoff(pl, 1, 1);
+  return GetPayoff(pl, 0, 1);
 }
 
 template <class T>
@@ -211,8 +211,9 @@ void TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, int const_pl, int c
 template <class T>
 T TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &strategy) const
 {
-  T value = T(0);
-  GetPayoffDeriv(pl, strategy->GetPlayer()->GetNumber(), 1, strategy->m_offset + 1, T(1), value);
+  T value = static_cast<T>(0);
+  GetPayoffDeriv(pl, strategy->GetPlayer()->GetNumber(), 1, strategy->m_offset, static_cast<T>(1),
+                 value);
   return value;
 }
 
@@ -249,12 +250,12 @@ T TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &st
   GamePlayerRep *player1 = strategy1->GetPlayer();
   GamePlayerRep *player2 = strategy2->GetPlayer();
   if (player1 == player2) {
-    return T(0);
+    return static_cast<T>(0);
   }
 
-  T value = T(0);
+  T value = static_cast<T>(0);
   GetPayoffDeriv(pl, player1->GetNumber(), player2->GetNumber(), 1,
-                 strategy1->m_offset + strategy2->m_offset + 1, T(1), value);
+                 strategy1->m_offset + strategy2->m_offset, static_cast<T>(1), value);
   return value;
 }
 
@@ -265,23 +266,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,12 +475,12 @@ 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 :
        StrategyContingencies(StrategySupportProfile(const_cast<GameTableRep *>(this)))) {
-    long newindex = 1L;
+    long newindex = 0L;
     for (const auto &player : m_players) {
       if (iter->GetStrategy(player)->m_offset < 0) {
         // This is a contingency involving a new strategy... skip
@@ -505,13 +492,11 @@ void GameTableRep::RebuildTable()
       }
     }
 
-    if (newindex >= 1) {
+    if (newindex >= 0L) {
       newResults[newindex] = iter->GetOutcome();
     }
   }
-
-  m_results = newResults;
-
+  std::copy(newResults.begin(), newResults.end(), m_results.begin());
   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
   //@{