Implement computation of all payoff first derivatives for a player at once.

Author: tturocy

src/games/game.cc

@@ -369,8 +369,20 @@ template <class T> void MixedStrategyProfile<T>::ComputePayoffs() const
   Cache newCache;
   for (const auto &player : m_rep->GetSupport().GetPlayers()) {
     newCache.m_payoffs[player] = GetPayoff(player);
-    for (const auto &strategy : m_rep->GetSupport().GetStrategies(player)) {
-      newCache.m_strategyValues[player][strategy] = GetPayoff(strategy);
+    const auto &strategies = m_rep->GetSupport().GetStrategies(player);
+    Vector<T> values(strategies.size());
+    if (m_rep->GetPayoffDerivs(player->GetNumber(), values)) {
+      auto value_it = values.begin();
+      for (const auto &strategy : strategies) {
+        newCache.m_strategyValues[player][strategy] = *value_it;
+        ++value_it;
+        ;
+      }
+    }
+    else {
+      for (const auto &strategy : m_rep->GetSupport().GetStrategies(player)) {
+        newCache.m_strategyValues[player][strategy] = GetPayoff(strategy);
+      }
     }
   }
   newCache.m_valid = true;

src/games/gametable.cc

@@ -282,6 +282,7 @@ template <class T> class TableMixedStrategyProfileRep : public MixedStrategyProf
   std::unique_ptr<MixedStrategyProfileRep<T>> Copy() const override;
   T GetPayoff(int pl) const override;
   T GetPayoffDeriv(int pl, const GameStrategy &) const override;
+  bool GetPayoffDerivs(int pl, Vector<T> &p_derivs) const override;
   T GetPayoffDeriv(int pl, const GameStrategy &, const GameStrategy &) const override;
 };
 
@@ -322,6 +323,26 @@ T TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &st
   return value;
 }
 
+template <class T>
+bool TableMixedStrategyProfileRep<T>::GetPayoffDerivs(int pl, Vector<T> &p_derivs) const
+{
+  const auto game = this->GetSupport().GetGame();
+  auto &g = dynamic_cast<GameTableRep &>(*game);
+  const auto player = game->GetPlayer(pl);
+  p_derivs = T{0};
+  auto segment = this->m_offsets.segment(pl);
+  for (auto [index, prob] : ProductDistribution<T>(this->m_probs, this->m_offsets, pl)) {
+    auto deriv_it = p_derivs.begin();
+    for (const auto base_index : segment) {
+      if (const auto outcome = g.m_results[base_index + index]) {
+        *deriv_it += prob * outcome->template GetPayoff<T>(player);
+        ++deriv_it;
+      }
+    }
+  }
+  return true;
+}
+
 template <class T>
 T TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &strategy1,
                                                   const GameStrategy &strategy2) const

src/games/stratmixed.h

@@ -98,6 +98,7 @@ template <class T> class MixedStrategyProfileRep {
   }
   virtual T GetPayoff(int pl) const = 0;
   virtual T GetPayoffDeriv(int pl, const GameStrategy &) const = 0;
+  virtual bool GetPayoffDerivs(int pl, Vector<T> &p_derivs) const { return false; }
   virtual T GetPayoffDeriv(int pl, const GameStrategy &, const GameStrategy &) const = 0;
 
   T GetPayoff(const GamePlayer &p_player) const { return GetPayoff(p_player->GetNumber()); }