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>

4 files changed, 173 insertions, 107 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c66a468..536e475 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,2 +1,5 @@
-add_executable(main main.cc)
+add_executable(main
+        main.cc
+        NameGame.cc
+)
 target_link_libraries(main PRIVATE SNAP::SNAP)
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
diff --git a/src/NameGame.h b/src/NameGame.h
new file mode 100644
index 0000000..8a817ce
--- /dev/null
+++ b/src/NameGame.h
@@ -0,0 +1,34 @@
+#ifndef TIPPING_POINTS_NAMEGAME_H
+#define TIPPING_POINTS_NAMEGAME_H
+
+#include <random>
+
+#include <Snap.h>
+
+namespace tp {
+
+class NameGame {
+public:
+        NameGame(int group_size, int cm_size, int memory = 12);
+
+        void setCMsize(int cm_size);
+
+        void initGraph();
+        void initMemory();
+        void run(int rounds);
+
+protected:
+        int best_move(int nId) const;
+        void update_memory(int nId, int strategy);
+
+private:
+        void runRound();
+        int gsize, cmsize, memlen;
+        std::mt19937 rng;
+        std::uniform_int_distribution<> dist;
+        TNodeNet<TPair<TBool, TIntV>> graph;
+}; // class NameGame
+
+} // namespace tp
+
+#endif // TIPPING_POINTS_NAMEGAME_H
diff --git a/src/main.cc b/src/main.cc
index 0f391eb..e41f4ff 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -1,119 +1,18 @@
-#include <cassert>
 #include <iostream>
-#include <map>
-#include <random>
 
-#include <Snap.h>
-
-void name_game(int group_size, int cmsize);
-
-constexpr int memory_length = 12;
-std::mt19937 rng(std::random_device{}());
+#include "NameGame.h"
 
 int main(int argc, char* argv[]) {
-        rng.seed(std::random_device{}());
         int group_size = 100;
+        tp::NameGame namegame(group_size, 0);
         for (int cmperc = 18; cmperc < 28; cmperc += 2) {
                 int cmsize = group_size * cmperc / 100;
+                namegame.setCMsize(cmsize);
+                namegame.initMemory();
                 std::cout << "CM " << cmsize << " / " << group_size << std::endl;
-                name_game(group_size, cmsize);
-        }
-        return 0;
-}
-
-using ngData = TPair<TBool, TIntV>;
-
-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();
-}
-
-int best_move(const ngData& d) {
-        const auto& mem = d.Val2;
-        std::map<int, int> votes;
-        for (const auto& v : mem) {
-                if (votes.count(v)) votes[v] += 1;
-                else votes[v] = 1;
+                namegame.run(10);
         }
-        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 update_memory(ngData& d, int move) {
-        if (!d.Val1) {
-                auto& mem = d.Val2;
-                mem.Ins(0, move);
-                mem.Trunc(memory_length);
-        }
-}
-
-void name_game_round(TNodeNet<ngData>& graph) {
-        std::uniform_int_distribution<> dist(0, graph.GetNodes());
-        // 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.GetDat());
-        std::cout << "speaker (" << speaker.GetId() << " "
-                << std::boolalpha << speaker().Val1
-                << ") chose: " << s_strategy << std::endl;
-
-        // Listener updates memory.
-        update_memory(hearer.GetDat(), s_strategy);
-
-        // Listener chooses best strategy.
-        int h_strategy = best_move(hearer.GetDat());
-        std::cout << "hearer (" << hearer.GetId() << " "
-                << std::boolalpha << hearer().Val1
-                << ") chose: " << h_strategy << std::endl;
-
-        // Speaker updates memory.
-        update_memory(speaker.GetDat(), s_strategy);
-}
-
-void name_game(int group_size, int cmsize) {
-        assert(cmsize > 0 && group_size > 0);
-        assert(cmsize < group_size);
-        TNodeNet<ngData> graph;
-        // Generate complete graph.
-        for (int i = 0; i < group_size; ++i) graph.AddNode(i, {false, {}});
-        for (int i = 0; i < group_size; ++i)
-                for (int j = 0; j < group_size; ++j)
-                        if (i != j) graph.AddEdge(i, j);
-        // Set committed minority.
-        std::uniform_int_distribution<> dist(0, group_size - 1);
-        for (int i = 0; i < cmsize;) {
-                int r = dist(rng);
-                if (!graph.GetNDat(r).Val1) {
-                        graph.GetNDat(r).Val1 = true;
-                        auto& mem = graph.GetNDat(r).Val2;
-                        mem.Clr();
-                        mem.Add(2);
-                        ++i;
-                }
-        }
-        // Establish norm (fully memory of strategy 1)
-        for (int i = 0; i < group_size; ++i) {
-                auto& d = graph.GetNDat(i);
-                if (!d.Val1) while (d.Val2.Len() < memory_length) d.Val2.Add(1);
-        }
-        std::cout << "Nodes: " << graph.GetNodes()
-                << " Edges: " << graph.GetEdges() << std::endl;
-
-        name_game_round(graph);
 
-        // Track all plays and plays by non-CM.
-        // Report average plays.
-}