Lp lcp

src/games/behavspt.cc

@@ -174,20 +174,30 @@ std::shared_ptr<GameSequenceForm> BehaviorSupportProfile::GetSequenceForm() cons
   return m_sequenceForm;
 }
 
-BehaviorSupportProfile::Sequences BehaviorSupportProfile::GetSequences() const { return {this}; }
+Sequences BehaviorSupportProfile::GetSequences() const { return {this}; }
 
-BehaviorSupportProfile::PlayerSequences
-BehaviorSupportProfile::GetSequences(GamePlayer &p_player) const
+GameSequence BehaviorSupportProfile::GetCorrespondingSequence(const GameAction &p_action) const
 {
-  return {this, p_player};
+  return GetSequenceForm()->m_correspondence.at(p_action);
 }
 
-int BehaviorSupportProfile::GetConstraintEntry(const GameInfoset &p_infoset,
-                                               const GameAction &p_action) const
+int BehaviorSupportProfile::GetSequenceConstraintEntry(const GameInfoset &p_infoset,
+                                                       const GameAction &p_action) const
 {
   return GetSequenceForm()->GetConstraintEntry(p_infoset, p_action);
 }
 
+PlayerSequences BehaviorSupportProfile::GetSequences(const GamePlayer &p_player) const
+{
+  return {this, p_player};
+}
+
+const Rational &
+BehaviorSupportProfile::GetTerminalProb(const std::map<GamePlayer, GameSequence> &p_profile) const
+{
+  return GetSequenceForm()->GetTerminalProb(p_profile);
+}
+
 const Rational &
 BehaviorSupportProfile::GetPayoff(const std::map<GamePlayer, GameSequence> &p_profile,
                                   const GamePlayer &p_player) const
@@ -220,80 +230,6 @@ BehaviorSupportProfile::ToMixedBehaviorProfile(const std::map<GameSequence, doub
   return b;
 }
 
-size_t BehaviorSupportProfile::Sequences::size() const
-{
-  return std::accumulate(m_support->GetSequenceForm()->m_sequences.cbegin(),
-                         m_support->GetSequenceForm()->m_sequences.cend(), 0,
-                         [](int acc, const std::pair<GamePlayer, std::vector<GameSequence>> &seq) {
-                           return acc + seq.second.size();
-                         });
-}
-
-BehaviorSupportProfile::Sequences::iterator BehaviorSupportProfile::Sequences::begin() const
-{
-  return {m_support->GetSequenceForm(), false};
-}
-BehaviorSupportProfile::Sequences::iterator BehaviorSupportProfile::Sequences::end() const
-{
-  return {m_support->GetSequenceForm(), true};
-}
-
-BehaviorSupportProfile::Sequences::iterator::iterator(
-    const std::shared_ptr<GameSequenceForm> p_sfg, bool p_end)
-  : m_sfg(p_sfg)
-{
-  if (p_end) {
-    m_currentPlayer = m_sfg->m_sequences.cend();
-  }
-  else {
-    m_currentPlayer = m_sfg->m_sequences.cbegin();
-    m_currentSequence = m_currentPlayer->second.cbegin();
-  }
-}
-
-BehaviorSupportProfile::Sequences::iterator &
-BehaviorSupportProfile::Sequences::iterator::operator++()
-{
-  if (m_currentPlayer == m_sfg->m_sequences.cend()) {
-    return *this;
-  }
-  m_currentSequence++;
-  if (m_currentSequence != m_currentPlayer->second.cend()) {
-    return *this;
-  }
-  m_currentPlayer++;
-  if (m_currentPlayer != m_sfg->m_sequences.cend()) {
-    m_currentSequence = m_currentPlayer->second.cbegin();
-  }
-  return *this;
-}
-
-bool BehaviorSupportProfile::Sequences::iterator::operator==(const iterator &it) const
-{
-  if (m_sfg != it.m_sfg || m_currentPlayer != it.m_currentPlayer) {
-    return false;
-  }
-  if (m_currentPlayer == m_sfg->m_sequences.end()) {
-    return true;
-  }
-  return (m_currentSequence == it.m_currentSequence);
-}
-
-std::vector<GameSequence>::const_iterator BehaviorSupportProfile::PlayerSequences::begin() const
-{
-  return m_support->GetSequenceForm()->m_sequences.at(m_player).begin();
-}
-
-std::vector<GameSequence>::const_iterator BehaviorSupportProfile::PlayerSequences::end() const
-{
-  return m_support->GetSequenceForm()->m_sequences.at(m_player).end();
-}
-
-size_t BehaviorSupportProfile::PlayerSequences::size() const
-{
-  return m_support->GetSequenceForm()->m_sequences.at(m_player).size();
-}
-
 BehaviorSupportProfile::SequenceContingencies::iterator::iterator(
     const std::shared_ptr<GameSequenceForm> p_sfg, bool p_end)
   : m_sfg(p_sfg), m_end(p_end)

src/games/behavspt.h

@@ -30,10 +30,6 @@
 namespace Gambit {
 
 class GameSequenceForm;
-class SequencesWrapper;
-class PlayerSequencesWrapper;
-class InfosetsWrapper;
-class ContingenciesWrapper;
 
 /// This class represents a subset of the actions in an extensive game.
 /// It is enforced that each player has at least one action at each
@@ -165,50 +161,6 @@ class BehaviorSupportProfile {
     }
   };
 
-  class Sequences {
-    const BehaviorSupportProfile *m_support;
-
-  public:
-    class iterator {
-      const std::shared_ptr<GameSequenceForm> m_sfg;
-      std::map<GamePlayer, std::vector<GameSequence>>::const_iterator m_currentPlayer;
-      std::vector<GameSequence>::const_iterator m_currentSequence;
-
-    public:
-      iterator(const std::shared_ptr<GameSequenceForm> p_sfg, bool p_end);
-
-      GameSequence operator*() const { return *m_currentSequence; }
-      GameSequence operator->() const { return *m_currentSequence; }
-
-      iterator &operator++();
-
-      bool operator==(const iterator &it) const;
-      bool operator!=(const iterator &it) const { return !(*this == it); }
-    };
-
-    Sequences(const BehaviorSupportProfile *p_support) : m_support(p_support) {}
-
-    size_t size() const;
-
-    iterator begin() const;
-    iterator end() const;
-  };
-
-  class PlayerSequences {
-    const BehaviorSupportProfile *m_support;
-    GamePlayer m_player;
-
-  public:
-    PlayerSequences(const BehaviorSupportProfile *p_support, const GamePlayer &p_player)
-      : m_support(p_support), m_player(p_player)
-    {
-    }
-
-    size_t size() const;
-    std::vector<GameSequence>::const_iterator begin() const;
-    std::vector<GameSequence>::const_iterator end() const;
-  };
-
   class SequenceContingencies {
     const BehaviorSupportProfile *m_support;
 
@@ -245,15 +197,17 @@ class BehaviorSupportProfile {
 
   std::shared_ptr<GameSequenceForm> GetSequenceForm() const;
   Sequences GetSequences() const;
-  PlayerSequences GetSequences(GamePlayer &p_player) const;
-  int GetConstraintEntry(const GameInfoset &p_infoset, const GameAction &p_action) const;
+  PlayerSequences GetSequences(const GamePlayer &p_player) const;
   const Rational &GetPayoff(const std::map<GamePlayer, GameSequence> &p_profile,
                             const GamePlayer &p_player) const;
+  const Rational &GetTerminalProb(const std::map<GamePlayer, GameSequence> &p_profile) const;
   GameRep::Players GetPlayers() const { return GetGame()->GetPlayers(); }
   MixedBehaviorProfile<double>
   ToMixedBehaviorProfile(const std::map<GameSequence, double> &) const;
   Infosets GetInfosets() const { return {this}; };
   SequenceContingencies GetSequenceContingencies() const;
+  GameSequence GetCorrespondingSequence(const GameAction &p_action) const;
+  int GetSequenceConstraintEntry(const GameInfoset &p_infoset, const GameAction &p_action) const;
 
   void FindReachableInfosets(GameNode p_node) const;
   std::shared_ptr<std::map<GameInfoset, bool>> GetReachableInfosets() const;

src/games/game.cc

@@ -32,6 +32,7 @@
 // editing operations into the game itself instead of in the member-object
 // classes.
 #include "gametree.h"
+#include "gameseq.h"
 
 namespace Gambit {
 
@@ -409,4 +410,74 @@ template class MixedStrategyProfileRep<Rational>;
 template class MixedStrategyProfile<double>;
 template class MixedStrategyProfile<Rational>;
 
+//========================================================================
+//    Sequences
+//========================================================================
+
+size_t Sequences::size() const
+{
+  return std::accumulate(m_support->GetSequenceForm()->m_sequences.cbegin(),
+                         m_support->GetSequenceForm()->m_sequences.cend(), 0,
+                         [](int acc, const std::pair<GamePlayer, std::vector<GameSequence>> &seq) {
+                           return acc + seq.second.size();
+                         });
+}
+
+Sequences::iterator Sequences::begin() const { return {m_support->GetSequenceForm(), false}; }
+Sequences::iterator Sequences::end() const { return {m_support->GetSequenceForm(), true}; }
+
+Sequences::iterator::iterator(const std::shared_ptr<GameSequenceForm> p_sfg, bool p_end)
+  : m_sfg(p_sfg)
+{
+  if (p_end) {
+    m_currentPlayer = m_sfg->m_sequences.cend();
+  }
+  else {
+    m_currentPlayer = m_sfg->m_sequences.cbegin();
+    m_currentSequence = m_currentPlayer->second.cbegin();
+  }
+}
+
+Sequences::iterator &Sequences::iterator::operator++()
+{
+  if (m_currentPlayer == m_sfg->m_sequences.cend()) {
+    return *this;
+  }
+  m_currentSequence++;
+  if (m_currentSequence != m_currentPlayer->second.cend()) {
+    return *this;
+  }
+  m_currentPlayer++;
+  if (m_currentPlayer != m_sfg->m_sequences.cend()) {
+    m_currentSequence = m_currentPlayer->second.cbegin();
+  }
+  return *this;
+}
+
+bool Sequences::iterator::operator==(const iterator &it) const
+{
+  if (m_sfg != it.m_sfg || m_currentPlayer != it.m_currentPlayer) {
+    return false;
+  }
+  if (m_currentPlayer == m_sfg->m_sequences.end()) {
+    return true;
+  }
+  return (m_currentSequence == it.m_currentSequence);
+}
+
+std::vector<GameSequence>::const_iterator PlayerSequences::begin() const
+{
+  return m_support->GetSequenceForm()->m_sequences.at(m_player).begin();
+}
+
+std::vector<GameSequence>::const_iterator PlayerSequences::end() const
+{
+  return m_support->GetSequenceForm()->m_sequences.at(m_player).end();
+}
+
+size_t PlayerSequences::size() const
+{
+  return m_support->GetSequenceForm()->m_sequences.at(m_player).size();
+}
+
 } // end namespace Gambit