Develop Strategies for game and use in liap solver.

Author: tturocy

src/core/util.h

@@ -157,6 +157,15 @@ auto minimize_function(const Container &p_container, const Func &p_function)
       [](const T &a, const T &b) -> T { return std::min(a, b); }, p_function);
 }
 
+/// @brief Returns the sum of the function over the container
+template <class Container, class Func>
+auto sum_function(const Container &p_container, const Func &p_function)
+{
+  using T = decltype(p_function(*(p_container.begin())));
+  return std::transform_reduce(p_container.begin(), p_container.end(), static_cast<T>(0),
+                               std::plus<T>(), p_function);
+}
+
 //========================================================================
 //                        Exception classes
 //========================================================================

src/games/game.h

@@ -824,6 +824,18 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   virtual Array<int> NumStrategies() const = 0;
   /// Gets the i'th strategy in the game, numbered globally
   virtual GameStrategy GetStrategy(int p_index) const = 0;
+  /// Gets the set of strategies in the game
+  std::vector<GameStrategy> GetStrategies() const
+  {
+    BuildComputedValues();
+    std::vector<GameStrategy> ret;
+    for (const auto &player : m_players) {
+      for (const auto &strategy : player->m_strategies) {
+        ret.emplace_back(strategy);
+      }
+    }
+    return ret;
+  }
   /// Creates a new strategy for the player
   virtual GameStrategy NewStrategy(const GamePlayer &p_player, const std::string &p_label)
   {

src/solvers/liap/nfgliap.cc

@@ -20,8 +20,6 @@
 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 //
 
-#include <numeric>
-
 #include "gambit.h"
 #include "core/function.h"
 #include "liap.h"
@@ -63,45 +61,41 @@ class StrategicLyapunovFunction : public FunctionOnSimplices {
 inline double sum_player_probs(const MixedStrategyProfile<double> &p_profile,
                                const GamePlayer &p_player)
 {
-  auto strategies = p_player->GetStrategies();
-  return std::accumulate(
-      strategies.cbegin(), strategies.cend(), 0.0,
-      [p_profile](double t, const GameStrategy &s) { return t + p_profile[s]; });
+  return sum_function(p_player->GetStrategies(),
+                      [&p_profile](const auto &s) -> double { return p_profile[s]; });
 }
 
 double StrategicLyapunovFunction::Value(const Vector<double> &v) const
 {
   m_profile = v;
   double value = 0;
-  // Liapunov function proper - should be replaced with call to profile once
-  // the penalty is removed from that implementation.
-  for (auto player : m_profile.GetGame()->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      value += sqr(
-          std::max(m_scale * (m_profile.GetPayoff(strategy) - m_profile.GetPayoff(player)), 0.0));
-    }
+  // Liapunov function proper
+  for (const auto &player : m_profile.GetGame()->GetPlayers()) {
+    const auto payoff = m_profile.GetPayoff(player);
+    value += sum_function(player->GetStrategies(), [this, &payoff](const auto &s) -> double {
+      return sqr(std::max(m_scale * (m_profile.GetPayoff(s) - payoff), 0.0));
+    });
   }
   // Penalty function for non-negativity constraint for each strategy
-  for (auto player : m_profile.GetGame()->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      value += m_penalty * sqr(std::min(m_profile[strategy], 0.0));
-    }
-  }
+  value += m_penalty * sum_function(m_profile.GetGame()->GetStrategies(), [&](const auto &s) {
+             return sqr(std::min(m_profile[s], 0.0));
+           });
   // Penalty function for sum-to-one constraint for each player
-  for (auto player : m_profile.GetGame()->GetPlayers()) {
-    value += m_penalty * sqr(sum_player_probs(m_profile, player) - 1.0);
-  }
+  value +=
+      m_penalty * sum_function(m_profile.GetGame()->GetPlayers(), [this](const auto &p) -> double {
+        return sqr(sum_player_probs(m_profile, p) - 1.0);
+      });
   return value;
 }
 
 double StrategicLyapunovFunction::LiapDerivValue(const MixedStrategyProfile<double> &p_profile,
                                                  const GameStrategy &p_wrt_strategy) const
 {
   double deriv = 0.0;
-  for (auto player : m_game->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      const double loss =
-          sqr(m_scale) * (p_profile.GetPayoff(strategy) - p_profile.GetPayoff(player));
+  for (const auto &player : m_game->GetPlayers()) {
+    const auto payoff = p_profile.GetPayoff(player);
+    for (const auto &strategy : player->GetStrategies()) {
+      const double loss = sqr(m_scale) * (p_profile.GetPayoff(strategy) - payoff);
       if (loss <= 0.0) {
         continue;
       }
@@ -121,13 +115,9 @@ double StrategicLyapunovFunction::LiapDerivValue(const MixedStrategyProfile<doub
 bool StrategicLyapunovFunction::Gradient(const Vector<double> &v, Vector<double> &d) const
 {
   m_profile = v;
-  auto element = d.begin();
-  for (auto player : m_game->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      *element = LiapDerivValue(m_profile, strategy);
-      ++element;
-    }
-  }
+  const auto strategies = m_profile.GetGame()->GetStrategies();
+  std::transform(strategies.begin(), strategies.end(), d.begin(),
+                 [&](const auto &s) -> double { return LiapDerivValue(m_profile, s); });
   Project(d, m_game->NumStrategies());
   return true;
 }
@@ -137,10 +127,8 @@ namespace {
 MixedStrategyProfile<double> EnforceNonnegativity(const MixedStrategyProfile<double> &p_profile)
 {
   auto profile = p_profile;
-  for (auto player : p_profile.GetGame()->GetPlayers()) {
-    for (auto strategy : player->GetStrategies()) {
-      profile[strategy] = std::max(profile[strategy], 0.0);
-    }
+  for (const auto &strategy : p_profile.GetGame()->GetStrategies()) {
+    profile[strategy] = std::max(profile[strategy], 0.0);
   }
   return profile.Normalize();
 }