created encapsulated NameGame class

- src/CMakeLists.txt: add NameGame.cc.
- src/NameGame.cc: move best_move, update_memory, run round, round into this
	class and file.
- move begin/end for TVec here.
- add initGraph and initMemory for changing sizes.
- src/NameGame.h: add class declaration.
- main.cc: move all functions out of here.
- use one object and re initialize memory for different committed minority
	sizes.

Signed-off-by: Aiden Woodruff <woodra@rpi.edu>

1 files changed, 130 insertions, 0 deletions

diff --git a/src/NameGame.cc b/src/NameGame.cc
new file mode 100644
index 0000000..8ea3dcf
--- /dev/null
+++ b/src/NameGame.cc
@@ -0,0 +1,130 @@
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include "NameGame.h"
+
+template<typename TVal, typename TSizeTy>
+auto begin(const TVec<TVal, TSizeTy>& v) -> decltype(v.BegI()) {
+        return v.BegI();
+}
+
+template<typename TVal, typename TSizeTy>
+auto end(const TVec<TVal, TSizeTy>& v) -> decltype(v.EndI()) {
+        return v.EndI();
+}
+
+namespace tp {
+
+NameGame::NameGame(int group_size, int cm_size, int memory) :
+        gsize(group_size), cmsize(cm_size), memlen(memory),
+        rng(std::random_device{}()), dist(0, group_size - 1),
+        graph(group_size, group_size * group_size)
+{
+        if (group_size <= 0)
+                throw std::invalid_argument("NameGame invalid group_size");
+        if (cm_size < 0)
+                throw std::invalid_argument("NameGame invalid cm_size");
+        if (cm_size > group_size)
+                throw std::invalid_argument("NameGame cm_size > group_size");
+        if (memory <= 0)
+                throw std::invalid_argument("NameGame memory <= 0");
+        initGraph();
+}
+
+void NameGame::setCMsize(int cm_size) {
+        if (cm_size <= 0 || cm_size > gsize)
+                throw std::invalid_argument("NameGame::setCMsize invalid cm_size");
+        cmsize = cm_size;
+}
+
+void NameGame::initGraph() {
+        // Generate complete graph.
+        for (int i = 0; i < gsize; ++i) graph.AddNode(i, {false, {}});
+        for (int i = 0; i < gsize; ++i)
+                for (int j = 0; j < gsize; ++j)
+                        if (i != j) graph.AddEdge(i, j);
+        initMemory();
+}
+
+void NameGame::initMemory() {
+        std::vector<int> ids(gsize);
+        std::iota(ids.begin(), ids.end(), 0);
+        // Set committed minority.
+        for (int i = 0; i < cmsize; ++i) {
+                int r = dist(rng) % ids.size();
+                int rId = ids[r];
+                auto& rDat = graph.GetNDat(rId);
+                rDat.Val1 = true;
+                rDat.Val2.Clr();
+                rDat.Val2.Add(2);
+                ids.erase(ids.begin() + r);
+        }
+        // Establish norm (fully memory of strategy 1) for remaining nodes.
+        for (int id : ids) {
+                auto& d = graph.GetNDat(id);
+                d.Val1 = false;
+                d.Val2.Clr();
+                while (d.Val2.Len() < memlen) d.Val2.Add(1);
+        }
+}
+
+void NameGame::run(int rounds) {
+        if (rounds < 0) throw std::invalid_argument("NameGame::run rounds < 0");
+        for (int i = 0; i < rounds; ++i) runRound();
+        // Track all plays and plays by non-CM.
+        // Report average plays.
+}
+
+void NameGame::runRound() {
+        // Select random speaker and hearer.
+        auto speaker = graph.GetNI(dist(rng));
+        auto hearer = graph.GetNI(
+                speaker.GetNbrNId(dist(rng) % speaker.GetDeg())
+        );
+
+        // Speaker chooses best strategy.
+        int s_strategy = best_move(speaker.GetId());
+        std::cout << "speaker (" << speaker.GetId() << " "
+                << std::boolalpha << speaker().Val1
+                << ") chose: " << s_strategy << std::endl;
+
+        // Listener updates memory.
+        update_memory(hearer.GetId(), s_strategy);
+
+        // Listener chooses best strategy.
+        int h_strategy = best_move(hearer.GetId());
+        std::cout << "hearer (" << hearer.GetId() << " "
+                << std::boolalpha << hearer().Val1
+                << ") chose: " << h_strategy << std::endl;
+
+        // Speaker updates memory.
+        update_memory(speaker.GetId(), s_strategy);
+}
+
+int NameGame::best_move(int nId) const {
+        const auto& mem = graph.GetNDat(nId).Val2;
+        std::map<int, int> votes;
+        for (const auto& v : mem) {
+                if (votes.count(v)) votes[v] += 1;
+                else votes[v] = 1;
+        }
+        std::map<int, float> fractions;
+        for (auto kv : votes) fractions[kv.first] = kv.second * 1./mem.Len();
+        // Simple majority vote:
+        for (auto kv : fractions)
+                if (kv.second >= 1./mem.Len()) return kv.first;
+        return 0;
+}
+
+void NameGame::update_memory(int nId, int strategy) {
+        auto d = graph.GetNDat(nId);
+        if (!d.Val1) {
+                auto& mem = d.Val2;
+                mem.Ins(0, strategy);
+                mem.Trunc(memlen);
+        }
+}
+
+} // namespace tp