Use std::vector in NewTable

Author: tturocy

src/games/file.cc

@@ -306,9 +306,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;

src/games/game.h

@@ -704,7 +704,7 @@ inline GameStrategy GamePlayerRep::GetStrategy(int st) const
 /// Factory function to create new game tree
 Game NewTree();
 /// Factory function to create new game table
-Game NewTable(const Array<int> &p_dim, bool p_sparseOutcomes = false);
+Game NewTable(const std::vector<int> &p_dim, bool p_sparseOutcomes = false);
 
 /// @brief Reads a game representation in .efg format
 ///

src/games/gametable.cc

@@ -64,7 +64,7 @@ std::shared_ptr<PureStrategyProfileRep> TablePureStrategyProfileRep::Copy() cons
   return std::make_shared<TablePureStrategyProfileRep>(*this);
 }
 
-Game NewTable(const Array<int> &p_dim, bool p_sparseOutcomes /*= false*/)
+Game NewTable(const std::vector<int> &p_dim, bool p_sparseOutcomes /*= false*/)
 {
   return new GameTableRep(p_dim, p_sparseOutcomes);
 }
@@ -265,12 +265,12 @@ template class TableMixedStrategyProfileRep<Rational>;
 //                     GameTableRep: Lifecycle
 //------------------------------------------------------------------------
 
-GameTableRep::GameTableRep(const Array<int> &dim, bool p_sparseOutcomes /* = false */)
+GameTableRep::GameTableRep(const std::vector<int> &dim, bool p_sparseOutcomes /* = false */)
   : m_results(std::accumulate(dim.begin(), dim.end(), 1, std::multiplies<>()))
 {
-  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);
+  for (const auto &nstrat : dim) {
+    m_players.push_back(new GamePlayerRep(this, m_players.size() + 1, nstrat));
+    m_players.back()->m_label = lexical_cast<std::string>(m_players.size());
     std::for_each(
         m_players.back()->m_strategies.begin(), m_players.back()->m_strategies.end(),
         [st = 1](GameStrategyRep *s) mutable { s->SetLabel(lexical_cast<std::string>(st++)); });

src/games/gametable.h

@@ -49,7 +49,7 @@ class GameTableRep : public GameExplicitRep {
   //@{
   /// Construct a new table game with the given dimension
   /// If p_sparseOutcomes = true, outcomes for all contingencies are left null
-  explicit GameTableRep(const Array<int> &p_dim, bool p_sparseOutcomes = false);
+  explicit GameTableRep(const std::vector<int> &p_dim, bool p_sparseOutcomes = false);
   Game Copy() const override;
   //@}
 

src/gui/gameframe.cc

@@ -636,9 +636,9 @@ void gbtGameFrame::OnFileNewEfg(wxCommandEvent &)
 
 void gbtGameFrame::OnFileNewNfg(wxCommandEvent &)
 {
-  Gambit::Array<int> dim(2);
+  std::vector<int> dim(2);
+  dim[0] = 2;
   dim[1] = 2;
-  dim[2] = 2;
   const Gambit::Game nfg = Gambit::NewTable(dim);
   nfg->SetTitle("Untitled Strategic Game");
   nfg->GetPlayer(1)->SetLabel("Player 1");

src/pygambit/gambit.pxd

@@ -2,6 +2,7 @@ from libcpp cimport bool
 from libcpp.string cimport string
 from libcpp.memory cimport shared_ptr, unique_ptr
 from libcpp.list cimport list as stdlist
+from libcpp.vector cimport vector as stdvector
 
 
 cdef extern from "gambit.h":
@@ -230,7 +231,7 @@ cdef extern from "games/game.h":
         c_MixedStrategyProfile[T] NewMixedStrategyProfile[T](T)  # except + doesn't compile
 
     c_Game NewTree() except +
-    c_Game NewTable(Array[int]) except +
+    c_Game NewTable(stdvector[int]) except +
 
 
 cdef extern from "games/stratpure.h":

src/pygambit/game.pxi

@@ -517,10 +517,7 @@ class Game:
         Game
             The newly-created strategic game.
         """
-        cdef Array[int] d
-        for v in dim:
-            d.push_back(v)
-        g = Game.wrap(NewTable(d))
+        g = Game.wrap(NewTable(list(dim)))
         g.title = title
         return g