From cfe9818aff95e7eb17e48b8fb8a43c059952a505 Mon Sep 17 00:00:00 2001
From: Francesco Bariatti <francesco.bariatti@insa-rennes.fr>
Date: Wed, 14 Oct 2015 16:08:36 +0200
Subject: [PATCH] Added initial project
---
.gitignore | 1 +
Makefile | 30 +++
src/game/connect4.cpp | 363 +++++++++++++++++++++++++++
src/game/connect4.hpp | 79 ++++++
src/game/game.hpp | 48 ++++
src/game/lines_of_action.cpp | 214 ++++++++++++++++
src/game/lines_of_action.hpp | 88 +++++++
src/game/test_connect4.cpp | 58 +++++
src/game/test_connect4.hpp | 14 ++
src/game/test_lines_of_action.cpp | 38 +++
src/game/test_lines_of_action.hpp | 15 ++
src/main/main.cpp | 26 ++
src/mcts/allocator.cpp | 84 +++++++
src/mcts/allocator.hpp | 28 +++
src/mcts/allocator.hpp~ | 28 +++
src/mcts/mcts.hpp | 31 +++
src/mcts/mcts_two_players.cpp | 7 +
src/mcts/mcts_two_players.hpp | 274 ++++++++++++++++++++
src/mcts/node.cpp | 24 ++
src/mcts/node.hpp | 138 ++++++++++
src/mcts/openings.cpp | 30 +++
src/mcts/openings.hpp | 115 +++++++++
src/mcts/statistics.cpp | 16 ++
src/mcts/statistics.hpp | 16 ++
src/mcts/test_allocator.cpp | 109 ++++++++
src/mcts/test_allocator.hpp | 29 +++
src/mcts/test_mcts_two_players.cpp | 280 +++++++++++++++++++++
src/mcts/test_mcts_two_players.hpp | 25 ++
src/minmax/connect4_heuristic.cpp | 11 +
src/minmax/connect4_heuristic.hpp | 14 ++
src/minmax/heuristic.hpp | 26 ++
src/minmax/minmax.hpp | 135 ++++++++++
src/minmax/test_minmax.cpp | 67 +++++
src/minmax/test_minmax.hpp | 16 ++
src/monte_carlo/monte_carlo.cpp | 12 +
src/monte_carlo/monte_carlo.hpp | 95 +++++++
src/monte_carlo/test_monte_carlo.cpp | 58 +++++
src/monte_carlo/test_monte_carlo.hpp | 18 ++
src/util/bits.cpp | 16 ++
src/util/bits.hpp | 27 ++
src/util/bits.hpp.gch | Bin 0 -> 2016048 bytes
src/util/display_node.cpp | 82 ++++++
src/util/display_node.hpp | 22 ++
src/util/fast_log.cpp | 29 +++
src/util/fast_log.hpp | 34 +++
src/util/learning.hpp | 46 ++++
src/util/omp_util.cpp | 23 ++
src/util/omp_util.hpp | 15 ++
src/util/pow.hpp | 25 ++
src/util/test_bits.cpp | 37 +++
src/util/test_bits.hpp | 14 ++
src/util/test_fast_log.cpp | 50 ++++
src/util/test_fast_log.hpp | 19 ++
53 files changed, 3099 insertions(+)
create mode 100644 Makefile
create mode 100644 src/game/connect4.cpp
create mode 100644 src/game/connect4.hpp
create mode 100644 src/game/game.hpp
create mode 100644 src/game/lines_of_action.cpp
create mode 100644 src/game/lines_of_action.hpp
create mode 100644 src/game/test_connect4.cpp
create mode 100644 src/game/test_connect4.hpp
create mode 100644 src/game/test_lines_of_action.cpp
create mode 100644 src/game/test_lines_of_action.hpp
create mode 100644 src/main/main.cpp
create mode 100644 src/mcts/allocator.cpp
create mode 100644 src/mcts/allocator.hpp
create mode 100644 src/mcts/allocator.hpp~
create mode 100644 src/mcts/mcts.hpp
create mode 100644 src/mcts/mcts_two_players.cpp
create mode 100644 src/mcts/mcts_two_players.hpp
create mode 100644 src/mcts/node.cpp
create mode 100644 src/mcts/node.hpp
create mode 100644 src/mcts/openings.cpp
create mode 100644 src/mcts/openings.hpp
create mode 100644 src/mcts/statistics.cpp
create mode 100644 src/mcts/statistics.hpp
create mode 100644 src/mcts/test_allocator.cpp
create mode 100644 src/mcts/test_allocator.hpp
create mode 100644 src/mcts/test_mcts_two_players.cpp
create mode 100644 src/mcts/test_mcts_two_players.hpp
create mode 100644 src/minmax/connect4_heuristic.cpp
create mode 100644 src/minmax/connect4_heuristic.hpp
create mode 100644 src/minmax/heuristic.hpp
create mode 100644 src/minmax/minmax.hpp
create mode 100644 src/minmax/test_minmax.cpp
create mode 100644 src/minmax/test_minmax.hpp
create mode 100644 src/monte_carlo/monte_carlo.cpp
create mode 100644 src/monte_carlo/monte_carlo.hpp
create mode 100644 src/monte_carlo/test_monte_carlo.cpp
create mode 100644 src/monte_carlo/test_monte_carlo.hpp
create mode 100644 src/util/bits.cpp
create mode 100644 src/util/bits.hpp
create mode 100644 src/util/bits.hpp.gch
create mode 100644 src/util/display_node.cpp
create mode 100644 src/util/display_node.hpp
create mode 100644 src/util/fast_log.cpp
create mode 100644 src/util/fast_log.hpp
create mode 100644 src/util/learning.hpp
create mode 100644 src/util/omp_util.cpp
create mode 100644 src/util/omp_util.hpp
create mode 100644 src/util/pow.hpp
create mode 100644 src/util/test_bits.cpp
create mode 100644 src/util/test_bits.hpp
create mode 100644 src/util/test_fast_log.cpp
create mode 100644 src/util/test_fast_log.hpp
diff --git a/.gitignore b/.gitignore
index e69de29..e660fd9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+bin/
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..210e189
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,30 @@
+CC=g++-4.9
+BIN=bin
+INCLUDE=-I src/game -I src/util -I src/monte_carlo -I src/mcts -I src/minmax
+CFLAGS=-g -O3 -ffast-math -fopenmp -c -Wall -std=c++11 $(INCLUDE)
+LDFLAGS=-fopenmp -std=c++11 #-lprofiler -Wl,-no_pie
+SOURCES=omp_util.cpp fast_log.cpp display_node.cpp connect4.cpp test_connect4.cpp monte_carlo.cpp test_monte_carlo.cpp test_fast_log.cpp\
+statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp test_mcts_two_players.cpp test_minmax.cpp\
+bits.cpp test_bits.cpp main.cpp
+OBJECTS=$(addprefix $(BIN)/, $(SOURCES:.cpp=.o))
+EXECUTABLE=$(BIN)/theturk
+vpath %.cpp src/game:src/main:src/util:src/monte_carlo:src/mcts:src/gdl:src/minmax
+
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+ $(CC) $(LDFLAGS) $(OBJECTS) -o $@
+
+-include $(BIN)/$(OBJECTS:.o=.d)
+
+$(BIN)/%.o: %.cpp
+ $(CC) -c $(CFLAGS) $< -o $(BIN)/$*.o
+ $(CC) -MM $(CFLAGS) $< > $(BIN)/$*.d
+ @mv -f $(BIN)/$*.d $(BIN)/$*.d.tmp
+ @sed -e 's|.*:|$(BIN)/$*.o:|' < $(BIN)/$*.d.tmp > $(BIN)/$*.d
+ @sed -e 's/.*://' -e 's/\\$$//' < $(BIN)/$*.d.tmp | fmt -1 | \
+ sed -e 's/^ *//' -e 's/$$/:/' >> $(BIN)/$*.d
+ @rm -f $(BIN)/$*.d.tmp
+
+clean:
+ rm -f $(BIN)/*.o $(BIN)/*.d $(EXECUTABLE)
diff --git a/src/game/connect4.cpp b/src/game/connect4.cpp
new file mode 100644
index 0000000..c7d4a71
--- /dev/null
+++ b/src/game/connect4.cpp
@@ -0,0 +1,363 @@
+#include "connect4.hpp"
+#include <sstream>
+
+using namespace std;
+
+namespace game
+{
+ static vector<vector<uint64_t>> create_hash_values()
+ {
+ default_random_engine generator;
+ uniform_int_distribution<uint64_t> distribution;
+ vector<vector<uint64_t>> res(7, vector<uint64_t>(6, 0));
+ for (int i = 0; i < 7; ++i)
+ {
+ for (int j = 0; j < 6; ++j)
+ {
+ res[i][j] = distribution(generator);
+ }
+ }
+ return res;
+ }
+
+ vector<vector<uint64_t>> connect4::cross_hash_values = create_hash_values();
+ vector<vector<uint64_t>> connect4::circle_hash_values = create_hash_values();
+
+ connect4::connect4()
+ {
+ }
+
+ shared_ptr<game<connect4_state>> connect4::do_copy() const
+ {
+ return shared_ptr<connect4>(new connect4(*this));
+ }
+
+ connect4_state connect4::get_state()
+ {
+ return state;
+ }
+
+ void connect4::set_state(const connect4_state& s)
+ {
+ state = s;
+ }
+
+ bool connect4::end_of_game() const
+ {
+ return state.first_player_win || state.second_player_win || state.total_moves == 42;
+ }
+
+ bool connect4::won(std::uint8_t player) const
+ {
+ if (player == 0) return state.first_player_win;
+ return state.second_player_win;
+ }
+
+ bool connect4::lost(std::uint8_t player) const
+ {
+ if (player == 0) return state.second_player_win;
+ return state.first_player_win;
+ }
+
+ bool connect4::draw(std::uint8_t player) const
+ {
+ if (state.first_player_win || state.second_player_win) return false;
+ return state.total_moves == 42;
+ }
+
+ uint8_t connect4::current_player() const
+ {
+ return state.total_moves & 1 ? CIRCLE : CROSS;
+ }
+
+ // uint8_t connect4::current_player_representation() const
+ // {
+ // return state.total_moves & 1 ? CIRCLE_REPRESENTATION : CROSS_REPRESENTATION;
+ // }
+
+ // uint8_t connect4::player_representation_to_player(uint8_t player) const
+ // {
+ // return player == CIRCLE_REPRESENTATION ? CIRCLE : (player == CROSS_REPRESENTATION ? CROSS : -1);
+ // }
+
+ int connect4::value(uint8_t player) const
+ {
+ if (player == CROSS)
+ {
+ return state.first_player_win ? 1 : (state.second_player_win ? -1 : 0);
+ }
+ else if (player == CIRCLE)
+ {
+ return state.second_player_win ? 1 : (state.first_player_win ? -1 : 0);
+ }
+ return 0;
+ }
+
+ uint16_t connect4::number_of_moves() const
+ {
+ return state.nb_moves;
+ }
+
+ bool connect4::get(uint64_t bitboard, uint8_t col, uint8_t row) const
+ {
+ return bitboard & (1LL << ((col << 3) + row));
+ //return (state.board[i] >> (j << 1)) & 3;
+ }
+
+#define set(bitboard, col, row) (bitboard |= (1LL << (((col) << 3) + (row))))
+
+ // bool connect4::vertical(uint8_t position, uint8_t free, uint8_t player) const
+ // {
+ // return free >= 3 && get(position, free - 1) == player && get(position, free - 2) == player && get(position, free - 3) == player;
+ // }
+
+ // bool connect4::horizontal(uint8_t position, uint8_t free, uint8_t player) const
+ // {
+ // uint8_t sum = 0;
+ // if (position >= 1 && get(position - 1, free) == player)
+ // {
+ // ++sum;
+ // if (position >= 2 && get(position - 2, free) == player)
+ // {
+ // ++sum;
+ // if (position >= 3 && get(position - 3, free) == player) ++sum;
+ // }
+ // }
+ // if (position <= 5 && get(position + 1, free) == player)
+ // {
+ // ++sum;
+ // if (position <= 4 && get(position + 2, free) == player)
+ // {
+ // ++sum;
+ // if (position <= 3 && get(position + 3, free) == player) ++sum;
+ // }
+ // }
+ // return sum >= 3;
+ // }
+
+ // bool connect4::diagonal(uint8_t position, uint8_t free, uint8_t player) const
+ // {
+ // uint8_t sum = 0;
+ // if (position >= 1 && free <= 4 && get(position - 1, free + 1) == player)
+ // {
+ // ++sum;
+ // if (position >= 2 && free <= 3 && get(position - 2, free + 2) == player)
+ // {
+ // ++sum;
+ // if (position >= 3 && free <= 2 && get(position - 3, free + 3) == player) ++sum;
+ // }
+ // }
+ // if (position <= 5 && free >= 1 && get(position + 1, free - 1) == player)
+ // {
+ // ++sum;
+ // if (position <= 4 && free >= 2 && get(position + 2, free - 2) == player)
+ // {
+ // ++sum;
+ // if (position <= 3 && free >= 3 && get(position + 3, free - 3) == player) ++sum;
+ // }
+ // }
+ // return sum >= 3;
+ // }
+
+ // bool connect4::other_diagonal(uint8_t position, uint8_t free, uint8_t player) const
+ // {
+ // uint8_t sum = 0;
+ // if (position >= 1 && free >= 1 && get(position - 1, free - 1) == player)
+ // {
+ // ++sum;
+ // if (position >= 2 && free >= 2 && get(position - 2, free - 2) == player)
+ // {
+ // ++sum;
+ // if (position >= 3 && free >= 3 && get(position - 3, free - 3) == player) ++sum;
+ // }
+ // }
+ // if (position <= 5 && free <= 4 && get(position + 1, free + 1) == player)
+ // {
+ // ++sum;
+ // if (position <= 4 && free <= 3 && get(position + 2, free + 2) == player)
+ // {
+ // ++sum;
+ // if (position <= 3 && free <= 2 && get(position + 3, free + 3) == player) ++sum;
+ // }
+ // }
+ // return sum >= 3;
+ // }
+
+ // void connect4::update_win(uint8_t position, uint8_t free)
+ // {
+ // uint8_t player = current_player_representation();
+ // bool win =
+ // vertical(position, free, player)
+ // ||
+ // horizontal(position, free, player)
+ // ||
+ // diagonal(position, free, player)
+ // ||
+ // other_diagonal(position, free, player);
+ // if (win)
+ // {
+ // if (player == CROSS_REPRESENTATION) state.first_player_win = true;
+ // else state.second_player_win = true;
+ // }
+ // }
+
+ void connect4::update_win()
+ {
+ if (has_won(state.cross_bitboard)) state.first_player_win = true;
+ else if (has_won(state.circle_bitboard)) state.second_player_win = true;
+ }
+
+ bool connect4::has_won(uint64_t bitboard)
+ {
+ int64_t y = bitboard & (bitboard >> 7);
+ if (y & (y >> 2 * 7)) // check \ diagonal
+ return true;
+ y = bitboard & (bitboard >> 8);
+ if (y & (y >> 2 * 8)) // check horizontal -
+ return true;
+ y = bitboard & (bitboard >> 9);
+ if (y & (y >> 2 * 9)) // check / diagonal
+ return true;
+ y = bitboard & (bitboard >> 1);
+ if (y & (y >> 2)) // check vertical |
+ return true;
+ return false;
+ }
+
+ void connect4::update_moves(uint16_t move)
+ {
+ --state.nb_moves;
+ uint32_t prefix = state.moves >> ((move + 1) * 3);
+ uint8_t shift = 32 - move * 3;
+ state.moves = (uint32_t)((uint64_t)state.moves << shift) >> shift;
+ state.moves |= prefix << (move * 3);
+ }
+
+ void connect4::play(uint16_t m)
+ {
+ uint8_t position = ((state.moves >> (m * 3)) & 7);
+ uint8_t p = position * 3;
+ uint8_t f = (state.free >> p) & 7;
+ // state.hash_value ^= current_player() == CIRCLE ? circle_hash_values[position][f] : cross_hash_values[position][f];
+ // state.board[position] |= current_player_representation() << (f << 1);
+ if (current_player() == CROSS)
+ {
+ set(state.cross_bitboard, position, f);
+ }
+ else
+ {
+ set(state.circle_bitboard, position, f);
+ }
+ update_win();
+ ++f;
+ state.free = (state.free & ~(((uint32_t)7) << p)) | (f << p);
+ if (f == 6)
+ {
+ update_moves(m);
+ }
+ ++state.total_moves;
+ }
+
+ string connect4::player_to_string(uint8_t player) const
+ {
+ return player == CROSS ? "X" : (player == CIRCLE ? "O" : " ");
+ }
+
+ string connect4::move_to_string(uint16_t m) const
+ {
+ uint8_t position = ((state.moves >> (m * 3)) & 7);
+ return std::to_string(position);
+ }
+
+ set<int> connect4::to_input_vector() const
+ {
+ set<int> res;
+ int k = 0;
+ if (current_player()) res.insert(k++);
+ for (int col = 0; col < 7; ++col)
+ {
+ for (int row = 0; row < 6; ++row)
+ {
+ if (get(state.cross_bitboard, col, row)) res.insert(k++);
+ }
+ }
+ for (int col = 0; col < 7; ++col)
+ {
+ for (int row = 0; row < 6; ++row)
+ {
+ if (get(state.circle_bitboard, col, row)) res.insert(k++);
+ }
+ }
+ return res;
+ }
+
+ void connect4::from_input_vector(const std::set<int>& input)
+ {
+ state = connect4_state();
+ for (int index : input)
+ {
+ if (index == 1) continue;
+ if (index <= 43)
+ {
+ index -= 2;
+ state.cross_bitboard |= 1LL << (index + (index / 6) * 2);
+ }
+ else
+ {
+ index -= 44;
+ state.circle_bitboard |= 1LL << (index + (index / 6) * 2);
+ }
+ state.total_moves += 1;
+ }
+ }
+
+ string connect4::to_string() const
+ {
+ stringbuf buffer;
+ ostream os(&buffer);
+ for (int y = 5; y >= 0; --y)
+ {
+ for (int k = 0; k < 7; ++k) os << "+-";
+ os << "+" << endl;
+ for (int x = 0; x < 7; ++x)
+ {
+ os << "|" << (get(state.cross_bitboard, x, y) ? player_to_string(CROSS) : (get(state.circle_bitboard, x, y) ? player_to_string(CIRCLE) : " "));
+ }
+ os << "|" << endl;
+ }
+ for (int k = 0; k < 7; ++k) os << "+-";
+ os << "+" << endl;
+ for (int k = 0; k < 7; ++k) os << " " << k;
+ os << endl;
+ return buffer.str();
+ }
+
+ void connect4::playout(mt19937& engine, int max_depth)
+ {
+ while (!end_of_game())
+ {
+ uniform_int_distribution<uint16_t> distribution(0, number_of_moves() - 1);
+ uint16_t move = distribution(engine);
+ play(move);
+ }
+ }
+
+ std::uint64_t connect4::hash() const
+ {
+ return state.hash_value;
+ }
+
+ std::uint64_t connect4::hash(std::uint16_t m) const
+ {
+ uint8_t position = ((state.moves >> (m * 3)) & 7);
+ uint8_t p = position * 3;
+ uint8_t f = (state.free >> p) & 7;
+ return state.hash_value ^ (current_player() == CIRCLE ? circle_hash_values[position][f] : cross_hash_values[position][f]);
+ }
+
+ ostream& operator<<(ostream& os, const connect4& c4)
+ {
+ os << c4.to_string() << endl;
+ return os;
+ }
+}
diff --git a/src/game/connect4.hpp b/src/game/connect4.hpp
new file mode 100644
index 0000000..369bd8e
--- /dev/null
+++ b/src/game/connect4.hpp
@@ -0,0 +1,79 @@
+#ifndef __CONNECT4_HPP__
+#define __CONNECT4_HPP__
+
+#include "game.hpp"
+#include <random>
+#include <array>
+#include <iostream>
+#include <memory>
+
+namespace game
+{
+
+ struct connect4_state
+ {
+ uint64_t cross_bitboard = 0;
+ uint64_t circle_bitboard = 0;
+ // std::array<uint16_t, 7> board{};
+ std::uint32_t moves = 0x1AC688;
+ std::uint32_t free = 0;
+ uint64_t hash_value = 0;
+ std::uint16_t nb_moves = 7;
+ uint8_t total_moves = 0;
+ bool first_player_win = false;
+ bool second_player_win = false;
+ };
+
+ class connect4 : public game<connect4_state>
+ {
+ public:
+ connect4();
+ connect4(const connect4& c4) = default;
+ connect4& operator=(const connect4& c4) = default;
+ bool end_of_game() const;
+ int value(std::uint8_t player) const;
+ bool won(std::uint8_t player) const;
+ bool lost(std::uint8_t player) const;
+ bool draw(std::uint8_t player) const;
+ uint8_t current_player() const;
+ std::uint16_t number_of_moves() const;
+ void play(std::uint16_t m);
+ void undo(std::uint16_t m) {}
+ std::string player_to_string(std::uint8_t player) const;
+ std::string move_to_string(std::uint16_t m) const;
+ std::string to_string() const;
+ void playout(std::mt19937& engine, int max_depth = -1);
+ std::set<int> to_input_vector() const;
+ void from_input_vector(const std::set<int>& input);
+ connect4_state get_state();
+ void set_state(const connect4_state& state);
+ std::shared_ptr<game<connect4_state>> do_copy() const;
+ std::uint64_t hash(std::uint16_t m) const;
+ std::uint64_t hash() const;
+
+ private:
+ inline void update_win();
+ inline bool has_won(uint64_t bitboard);
+ inline void update_moves(uint16_t move);
+ inline bool get(uint64_t bitboard, uint8_t i, uint8_t j) const;
+ // inline bool vertical(uint8_t position, uint8_t free, uint8_t player) const;
+ // inline bool horizontal(uint8_t position, uint8_t free, uint8_t player) const;
+ // inline bool diagonal(uint8_t position, uint8_t free, uint8_t player) const;
+ // inline bool other_diagonal(uint8_t position, uint8_t free, uint8_t player) const;
+ // inline uint8_t current_player_representation() const;
+ // inline uint8_t player_representation_to_player(uint8_t player) const;
+
+ const uint8_t CROSS = 0;
+ const uint8_t CIRCLE = 1;
+ // const uint8_t CROSS_REPRESENTATION = 1;
+ // const uint8_t CIRCLE_REPRESENTATION = 2;
+
+ connect4_state state;
+
+ static std::vector<std::vector<uint64_t>> cross_hash_values;
+ static std::vector<std::vector<uint64_t>> circle_hash_values;
+ };
+ std::ostream& operator<<(std::ostream& os, const connect4& c4);
+}
+
+#endif
diff --git a/src/game/game.hpp b/src/game/game.hpp
new file mode 100644
index 0000000..20f5e2f
--- /dev/null
+++ b/src/game/game.hpp
@@ -0,0 +1,48 @@
+#ifndef __GAME_HPP__
+#define __GAME_HPP__
+
+#include <string>
+#include <cstdint>
+#include <random>
+#include <memory>
+#include <set>
+
+namespace game
+{
+ template <typename State>
+ struct game
+ {
+ virtual bool end_of_game() const = 0;
+ virtual int value(std::uint8_t player) const = 0;
+ int value_for_current_player() const;
+ virtual bool won(std::uint8_t player) const = 0;
+ virtual bool lost(std::uint8_t player) const = 0;
+ virtual bool draw(std::uint8_t player) const = 0;
+ virtual uint8_t current_player() const = 0;
+ virtual std::uint16_t number_of_moves() const = 0;
+ virtual void play(std::uint16_t m) = 0;
+ virtual void undo(std::uint16_t m) = 0;
+ virtual std::string player_to_string(std::uint8_t player) const = 0;
+ virtual std::string move_to_string(std::uint16_t m) const = 0;
+ virtual std::string to_string() const = 0;
+ virtual void playout(std::mt19937& engine, int max_depth = -1) = 0;
+ virtual std::set<int> to_input_vector() const = 0;
+ virtual void from_input_vector(const std::set<int>& input) = 0;
+ virtual State get_state() = 0;
+ virtual void set_state(const State& state) = 0;
+ virtual std::shared_ptr<game<State>> do_copy() const = 0;
+ virtual std::uint64_t hash(std::uint16_t m) const = 0;
+ virtual std::uint64_t hash() const = 0;
+ virtual ~game() {}
+ };
+ template<typename Game> std::shared_ptr<Game> copy(const Game& g)
+ {
+ return std::dynamic_pointer_cast<Game>(g.do_copy());
+ }
+ template<typename State> int game<State>::value_for_current_player() const
+ {
+ return value(current_player());
+ }
+}
+
+#endif
diff --git a/src/game/lines_of_action.cpp b/src/game/lines_of_action.cpp
new file mode 100644
index 0000000..48120d0
--- /dev/null
+++ b/src/game/lines_of_action.cpp
@@ -0,0 +1,214 @@
+#include "lines_of_action.hpp"
+#include <sstream>
+
+using namespace std;
+
+namespace game
+{
+ static vector<vector<uint64_t>> create_hash_values()
+ {
+ default_random_engine generator;
+ uniform_int_distribution<uint64_t> distribution;
+ vector<vector<uint64_t>> res(8, vector<uint64_t>(8, 0));
+ for (int i = 0; i < 8; ++i)
+ {
+ for (int j = 0; j < 8; ++j)
+ {
+ res[i][j] = distribution(generator);
+ }
+ }
+ return res;
+ }
+
+ vector<vector<uint64_t>> lines_of_action::black_hash_values = create_hash_values();
+ vector<vector<uint64_t>> lines_of_action::white_hash_values = create_hash_values();
+
+ shared_ptr<game<lines_of_action_state>> lines_of_action::do_copy() const
+ {
+ return shared_ptr<lines_of_action>(new lines_of_action(*this));
+ }
+
+ lines_of_action_state lines_of_action::get_state()
+ {
+ return state;
+ }
+
+ void lines_of_action::set_state(const lines_of_action_state& s)
+ {
+ state = s;
+ }
+
+ bool lines_of_action::end_of_game() const
+ {
+ return state.first_player_win || state.second_player_win;
+ }
+
+ bool lines_of_action::won(std::uint8_t player) const
+ {
+ if (player == 0) return state.first_player_win;
+ return state.second_player_win;
+ }
+
+ bool lines_of_action::lost(std::uint8_t player) const
+ {
+ if (player == 0) return state.second_player_win;
+ return state.first_player_win;
+ }
+
+ bool lines_of_action::draw(std::uint8_t player) const
+ {
+ return false;
+ }
+
+ uint8_t lines_of_action::current_player() const
+ {
+ return state.depth & 1 ? WHITE : BLACK;
+ }
+
+ int lines_of_action::value(uint8_t player) const
+ {
+ if (player == BLACK)
+ {
+ return state.first_player_win ? 1 : (state.second_player_win ? -1 : 0);
+ }
+ else if (player == WHITE)
+ {
+ return state.second_player_win ? 1 : (state.first_player_win ? -1 : 0);
+ }
+ return 0;
+ }
+
+ uint16_t lines_of_action::number_of_moves() const
+ {
+ return state.nb_moves;
+ }
+
+#define coord2bit(i, j) (1LL << (((i)<<3) + (j)))
+
+ uint8_t lines_of_action::get(uint8_t i, uint8_t j) const
+ {
+ if (state.black_bitboard & coord2bit(i, j)) return BLACK;
+ if (state.white_bitboard & coord2bit(i, j)) return WHITE;
+ return EMPTY;
+ }
+
+#define is_set(bitboard, i, j) (bitboard & coord2bit(i, j))
+
+ bool lines_of_action::is_valid_row_right(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const
+ {
+ uint8_t dest_j = from_j + n;
+ if (dest_j > 7) return false;
+ if (is_set(bitboard1, from_i, dest_j)) return false;
+ for (int j = from_j + 1; j < dest_j; ++j)
+ {
+ if (is_set(bitboard2, from_i, j)) return false;
+ }
+ return true;
+ }
+
+ bool lines_of_action::is_valid_row_left(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const
+ {
+ if (n > from_j) return false;
+ uint8_t dest_j = from_j - n;
+ if (is_set(bitboard1, from_i, dest_j)) return false;
+ for (int j = from_j - 1; j > dest_j; --j)
+ {
+ if (is_set(bitboard2, from_i, j)) return false;
+ }
+ return true;
+ }
+
+ bool lines_of_action::is_valid_column_up(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const
+ {
+ if (n > from_i) return false;
+ uint8_t dest_i = from_i - n;
+ if (is_set(bitboard1, dest_i, from_j)) return false;
+ for (int i = from_i - 1; i > dest_i; --i)
+ {
+ if (is_set(bitboard2, i, from_j)) return false;
+ }
+ return true;
+ }
+
+ bool lines_of_action::is_valid_column_down(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const
+ {
+ uint8_t dest_i = from_i + n;
+ if (dest_i > 7) return false;
+ if (is_set(bitboard1, dest_i, from_j)) return false;
+ for (int i = from_i + 1; i < dest_i; ++i)
+ {
+ if (is_set(bitboard2, i, from_j)) return false;
+ }
+ return true;
+ }
+
+ void lines_of_action::update_state(const move& m)
+ {
+
+ }
+
+ void lines_of_action::play(uint16_t m)
+ {
+ update_state(move_index_to_move(m));
+ }
+
+ string lines_of_action::player_to_string(uint8_t player) const
+ {
+ return player == BLACK ? "@" : (player == WHITE ? "O" : " ");
+ }
+
+ string lines_of_action::move_to_string(uint16_t m) const
+ {
+ return move_index_to_move(m).to_string();
+ }
+
+ string lines_of_action::to_string() const
+ {
+ stringbuf buffer;
+ ostream os(&buffer);
+ os << " a b c d e f g h" << endl;
+ for (int i = 0; i < 8; ++i)
+ {
+ os << " ";
+ for (int k = 0; k < 8; ++k) os << "+-";
+ os << "+" << endl;
+ os << 8 - i << "|";
+ for (int j = 0; j < 8; ++j)
+ {
+ os << player_to_string(get(i, j)) << "|";
+ }
+ os << 8 - i << endl;
+ }
+ os << " ";
+ for (int k = 0; k < 8; ++k) os << "+-";
+ os << "+" << endl;
+ os << " a b c d e f g h" << endl;
+ return buffer.str();
+ }
+
+ void lines_of_action::playout(mt19937& engine, int max_depth)
+ {
+ while (state.depth <= max_depth && !end_of_game())
+ {
+ uniform_int_distribution<uint16_t> distribution(0, number_of_moves() - 1);
+ uint16_t move = distribution(engine);
+ play(move);
+ }
+ }
+
+ std::uint64_t lines_of_action::hash() const
+ {
+ return state.hash_value;
+ }
+
+ std::uint64_t lines_of_action::hash(std::uint16_t m) const
+ {
+ return 0;
+ }
+
+ ostream& operator<<(ostream& os, const lines_of_action& loa)
+ {
+ os << loa.to_string() << endl;
+ return os;
+ }
+}
diff --git a/src/game/lines_of_action.hpp b/src/game/lines_of_action.hpp
new file mode 100644
index 0000000..5138f44
--- /dev/null
+++ b/src/game/lines_of_action.hpp
@@ -0,0 +1,88 @@
+#ifndef __LINES_OF_ACTION_HPP__
+#define __LINES_OF_ACTION_HPP__
+
+#include "game.hpp"
+#include <random>
+#include <array>
+#include <vector>
+#include <iostream>
+#include <memory>
+
+namespace game
+{
+
+ struct lines_of_action_state
+ {
+ uint64_t black_bitboard = 0x7E0000000000007E;
+ uint64_t white_bitboard = 0x0081818181818100;
+ uint32_t row_nb_pieces = 0x62222226;
+ uint32_t column_nb_pieces = 0x62222226;
+ uint64_t left_to_right_diagonal_nb_pieces = 0x0022222202222220;
+ uint64_t right_to_left_diagonal_nb_pieces = 0x0022222202222220;
+ uint64_t hash_value = 0;
+ uint16_t nb_moves = 48;
+ uint8_t black_nb_pieces = 12;
+ uint8_t white_nb_pieces = 12;
+ uint8_t depth = 0;
+ bool first_player_win = false;
+ bool second_player_win = false;
+ };
+
+ class lines_of_action : public game<lines_of_action_state>
+ {
+ public:
+ lines_of_action() = default;
+ lines_of_action(const lines_of_action& loa) = default;
+ lines_of_action& operator=(const lines_of_action& loa) = default;
+ bool end_of_game() const;
+ int value(std::uint8_t player) const;
+ bool won(std::uint8_t player) const;
+ bool lost(std::uint8_t player) const;
+ bool draw(std::uint8_t player) const;
+ uint8_t current_player() const;
+ std::uint16_t number_of_moves() const;
+ void play(std::uint16_t m);
+ void undo(std::uint16_t m) {}
+ std::string player_to_string(std::uint8_t player) const;
+ std::string move_to_string(std::uint16_t m) const;
+ std::string to_string() const;
+ void playout(std::mt19937& engine, int max_depth = -1);
+ lines_of_action_state get_state();
+ void set_state(const lines_of_action_state& state);
+ std::shared_ptr<game<lines_of_action_state>> do_copy() const;
+ std::uint64_t hash(std::uint16_t m) const;
+ std::uint64_t hash() const;
+ private:
+ const uint8_t BLACK = 0;
+ const uint8_t WHITE = 1;
+ const uint8_t EMPTY = 2;
+ struct move
+ {
+ uint8_t from_i, from_j;
+ uint8_t to_i, to_j;
+ move(uint8_t fi, uint8_t fj, uint8_t ti, uint8_t tj) : from_i(fi), from_j(fj), to_i(ti), to_j(tj) {}
+ std::string to_string() const
+ {
+ return char('a' + from_j) + std::to_string(8 - from_i) + "-" +
+ char('a' + to_j) + std::to_string(8 - to_i);
+ }
+ };
+ lines_of_action_state state;
+ inline uint8_t get(uint8_t i, uint8_t j) const;
+ inline bool is_valid_row_right(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_row_left(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_column_up(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_column_down(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_left_to_right_diagonal_up(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_left_to_right_diagonal_down(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_right_to_left_diagonal_up(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ inline bool is_valid_right_to_left_diagonal_down(uint64_t bitboard1, uint64_t bitboard2, uint8_t from_i, uint8_t from_j, uint8_t n) const;
+ move move_index_to_move(uint16_t m) const;
+ void update_state(const move& m);
+ static std::vector<std::vector<uint64_t>> black_hash_values;
+ static std::vector<std::vector<uint64_t>> white_hash_values;
+ };
+ std::ostream& operator<<(std::ostream& os, const lines_of_action& loa);
+}
+
+#endif
diff --git a/src/game/test_connect4.cpp b/src/game/test_connect4.cpp
new file mode 100644
index 0000000..4269f32
--- /dev/null
+++ b/src/game/test_connect4.cpp
@@ -0,0 +1,58 @@
+#include "connect4.hpp"
+#include "test_connect4.hpp"
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+namespace game
+{
+ test_connect4::test_connect4()
+ {
+ playout();
+ play();
+ }
+
+ void test_connect4::playout()
+ {
+ mt19937 mt;
+ connect4 c4;
+ cout << "playout" << endl;
+ for (int i = 0; i < 100; ++i)
+ {
+ uint8_t player = c4.current_player();
+ auto state = c4.get_state();
+ c4.playout(mt);
+ cout << "value: " << c4.value(player) << endl << c4 << endl;
+ c4.set_state(state);
+ string wait;
+ getline(cin, wait);
+ }
+ }
+
+ void test_connect4::play()
+ {
+ connect4 c4;
+ int player = 0;
+ cout << "play one game" << endl;
+ while (!c4.end_of_game())
+ {
+ cout << c4 << endl;
+ cout << c4.player_to_string(player) << " move: ";
+ map<string, int> m;
+ for (int i = 0; i < c4.number_of_moves(); ++i)
+ {
+ m[c4.move_to_string(i)] = i;
+ }
+ string move;
+ cin >> move;
+ c4.play(m[move]);
+ player = 1 - player;
+ }
+ cout << c4 << endl;
+ if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
+ else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
+ else cout << "draw";
+ cout << endl;
+ }
+}
diff --git a/src/game/test_connect4.hpp b/src/game/test_connect4.hpp
new file mode 100644
index 0000000..1ecee24
--- /dev/null
+++ b/src/game/test_connect4.hpp
@@ -0,0 +1,14 @@
+#ifndef __TEST_CONNECT4_HPP__
+#define __TEST_CONNECT4_HPP__
+
+namespace game
+{
+ class test_connect4
+ {
+ void playout();
+ void play();
+ public:
+ test_connect4();
+ };
+}
+#endif
diff --git a/src/game/test_lines_of_action.cpp b/src/game/test_lines_of_action.cpp
new file mode 100644
index 0000000..70347d1
--- /dev/null
+++ b/src/game/test_lines_of_action.cpp
@@ -0,0 +1,38 @@
+#include "test_lines_of_action.hpp"
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+namespace game
+{
+ test_lines_of_action::test_lines_of_action()
+ {
+ play();
+ }
+
+ void test_lines_of_action::play()
+ {
+ lines_of_action loa;
+ int player = 0;
+ cout << "play one game" << endl;
+ while (!loa.end_of_game())
+ {
+ cout << loa << endl;
+ cout << loa.player_to_string(player) << " move: ";
+ map<string, int> m;
+ for (int i = 0; i < loa.number_of_moves(); ++i)
+ {
+ m[loa.move_to_string(i)] = i;
+ }
+ string move;
+ cin >> move;
+ loa.play(m[move]);
+ player = 1 - player;
+ }
+ cout << loa << endl;
+ if (loa.value(0) == 1) cout << loa.player_to_string(0) << " won";
+ cout << loa.player_to_string(1) << " won";
+ cout << endl;
+ }
+}
diff --git a/src/game/test_lines_of_action.hpp b/src/game/test_lines_of_action.hpp
new file mode 100644
index 0000000..28f4be6
--- /dev/null
+++ b/src/game/test_lines_of_action.hpp
@@ -0,0 +1,15 @@
+#ifndef __TEST_LINES_OF_ACTION_HPP__
+#define __TEST_LINES_OF_ACTION_HPP__
+
+#include "lines_of_action.hpp"
+
+namespace game
+{
+ class test_lines_of_action
+ {
+ void play();
+ public:
+ test_lines_of_action();
+ };
+}
+#endif
diff --git a/src/main/main.cpp b/src/main/main.cpp
new file mode 100644
index 0000000..5451eeb
--- /dev/null
+++ b/src/main/main.cpp
@@ -0,0 +1,26 @@
+#include "test_connect4.hpp"
+#include "test_monte_carlo.hpp"
+#include "test_fast_log.hpp"
+#include "test_allocator.hpp"
+#include "test_mcts_two_players.hpp"
+#include "test_minmax.hpp"
+#include "test_bits.hpp"
+#include "learning.hpp"
+
+#include <omp.h>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+ // game::test_connect4();
+ // util::test_fast_log(100000000);
+ // mcts::test_allocator(10, 2);
+ // omp_set_num_threads(8);
+ mcts::test_mcts_two_players();
+ // minmax::test_minmax();
+ //util::test_bits(200000000);
+ //game::connect4 c4;
+ // util::learning::display_file(c4, "learning_examples.txt");
+ return 0;
+}
diff --git a/src/mcts/allocator.cpp b/src/mcts/allocator.cpp
new file mode 100644
index 0000000..3dc2309
--- /dev/null
+++ b/src/mcts/allocator.cpp
@@ -0,0 +1,84 @@
+#include "allocator.hpp"
+#include <iostream>
+#include <cstring>
+
+namespace mcts
+{
+ allocator::allocator(unsigned int size)
+ {
+ std::cout << "allocator initialization..." << std::endl;
+ node_arena = new node[size];
+ std::cout << "allocator initialization done" << std::endl;
+ limit = node_arena + size;
+ free_pointer = node_arena;
+ }
+
+ allocator::~allocator()
+ {
+ delete[] node_arena;
+ }
+
+ node* allocator::allocate(unsigned int size)
+ {
+ node* n;
+#pragma GCC diagnostic ignored "-Wunused-value"
+#pragma omp atomic capture
+ {
+ n = free_pointer;
+ free_pointer += size;
+ }
+ memset(n, 0, sizeof(node) * size);
+ if (n + size >= limit) throw "allocate_children: not enough memory";
+ return n;
+ }
+
+ unsigned int allocator::size() const
+ {
+ return limit - node_arena;
+ }
+
+ unsigned int allocator::free_space() const
+ {
+ return limit - free_pointer;
+ }
+
+ void allocator::clear()
+ {
+ free_pointer = node_arena;
+ }
+
+ node* allocator::allocate_unsafe(unsigned int size)
+ {
+ node* n = free_pointer;
+ free_pointer += size;
+ memset(n, 0, sizeof(node) * size);
+ if (n + size > limit) throw "allocate_children: not enough memory";
+ return n;
+ }
+
+ void allocator::copy(node* n1, node* n2, unsigned int prunning)
+ {
+ if (n1->get_statistics().count < prunning) return;
+ n2->set_statistics(n1->get_statistics());
+ unsigned int nb_children = n1->get_number_of_children();
+ n2->set_number_of_children(nb_children);
+ if (nb_children == 0) return;
+ n2->set_children(allocate_unsafe(nb_children));
+ node* children1 = n1->get_children();
+ node* children2 = n2->get_children();
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ copy(children1 + i, children2 + i, prunning);
+ }
+ }
+
+ node* allocator::move(node* root, unsigned int prunning)
+ {
+ node* r = allocate_unsafe(1);
+ copy(root, r, prunning);
+ free_pointer = node_arena;
+ node* res = allocate_unsafe(1);
+ copy(r, res);
+ return res;
+ }
+}
diff --git a/src/mcts/allocator.hpp b/src/mcts/allocator.hpp
new file mode 100644
index 0000000..9ee2787
--- /dev/null
+++ b/src/mcts/allocator.hpp
@@ -0,0 +1,28 @@
+#ifndef __ALLOCATOR_HPP__
+#define __ALLOCATOR_HPP__
+
+#include "node.hpp"
+
+namespace mcts
+{
+ class allocator
+ {
+ node* node_arena;
+ node* limit;
+ node* free_pointer;
+
+ node* allocate_unsafe(unsigned int size);
+ void copy(node* n1, node* n2, unsigned int prunning = 0);
+
+ public:
+ allocator(unsigned int size = 20000000U);
+ ~allocator();
+ node* allocate(unsigned int size);
+ void clear();
+ node* move(node* root, unsigned int prunning = 0);
+ unsigned int size() const;
+ unsigned int free_space() const;
+ };
+}
+
+#endif
diff --git a/src/mcts/allocator.hpp~ b/src/mcts/allocator.hpp~
new file mode 100644
index 0000000..150a2ff
--- /dev/null
+++ b/src/mcts/allocator.hpp~
@@ -0,0 +1,28 @@
+#ifndef __ALLOCATOR_HPP__
+#define __ALLOCATOR_HPP__
+
+#include "node.hpp"
+
+namespace mcts
+{
+ class allocator
+ {
+ node* node_arena;
+ node* limit;
+ node* free_pointer;
+
+ node* allocate_unsafe(unsigned int size);
+ void copy(node* n1, node* n2, unsigned int prunning = 0);
+
+ public:
+ allocator(unsigned int size = 1000000U);
+ ~allocator();
+ node* allocate(unsigned int size);
+ void clear();
+ node* move(node* root, unsigned int prunning = 0);
+ unsigned int size() const;
+ unsigned int free_space() const;
+ };
+}
+
+#endif
diff --git a/src/mcts/mcts.hpp b/src/mcts/mcts.hpp
new file mode 100644
index 0000000..66865d1
--- /dev/null
+++ b/src/mcts/mcts.hpp
@@ -0,0 +1,31 @@
+#ifndef __MCTS_HPP__
+#define __MCTS_HPP__
+
+#include <random>
+#include <chrono>
+#include <vector>
+#include "game.hpp"
+#include "node.hpp"
+
+namespace mcts
+{
+ template <typename Game>
+ class mcts
+ {
+ protected:
+ Game& game;
+ std::chrono::milliseconds milliseconds;
+ std::vector<std::mt19937> generators;
+ node* root;
+
+ public:
+ mcts(Game& game, uint32_t milliseconds) : game(game), milliseconds(milliseconds) {}
+
+ virtual void reset() = 0;
+ virtual uint16_t select_move() = 0;
+ virtual void last_moves(uint16_t m1, uint16_t m2) {}
+ virtual void last_moves(const std::vector<uint16_t>& moves) {}
+ };
+}
+
+#endif
diff --git a/src/mcts/mcts_two_players.cpp b/src/mcts/mcts_two_players.cpp
new file mode 100644
index 0000000..f3e31c0
--- /dev/null
+++ b/src/mcts/mcts_two_players.cpp
@@ -0,0 +1,7 @@
+#include "mcts_two_players.hpp"
+
+using namespace std;
+
+namespace mcts
+{
+}
diff --git a/src/mcts/mcts_two_players.hpp b/src/mcts/mcts_two_players.hpp
new file mode 100644
index 0000000..29e4e96
--- /dev/null
+++ b/src/mcts/mcts_two_players.hpp
@@ -0,0 +1,274 @@
+#ifndef __MCTS_TWO_PLAYERS_HPP__
+#define __MCTS_TWO_PLAYERS_HPP__
+
+#include "mcts.hpp"
+#include "allocator.hpp"
+#include "fast_log.hpp"
+#include "omp_util.hpp"
+#include "display_node.hpp"
+#include <fstream>
+#include <vector>
+#include "openings.hpp"
+
+namespace mcts
+{
+ template <typename Game>
+ class mcts_two_players : public mcts<Game>
+ {
+ allocator alloc_;
+ const util::fast_log fast_log_;
+ const float C_;
+ const unsigned int nb_visits_before_expansion_;
+ const bool new_version_;
+
+ inline node* select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent);
+ inline void expand(const std::shared_ptr<Game>& game, node* n);
+ void think(const std::shared_ptr<Game>& game);
+ public:
+ mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true);
+ void reset();
+ void init_with_openings(const openings& o);
+ inline uint16_t select_move();
+ void last_move(uint16_t move);
+ void last_moves(uint16_t computer, uint16_t other);
+ };
+
+ template <typename Game>
+ mcts_two_players<Game> make_mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true)
+ {
+ return mcts_two_players<Game>(game, milliseconds, C, nb_visits_before_expansion, new_version);
+ }
+
+ template <typename Game>
+ mcts_two_players<Game>::mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion, bool new_version)
+ : mcts<Game>(game, milliseconds), C_(C), nb_visits_before_expansion_(nb_visits_before_expansion), new_version_(new_version)
+ {
+ this->generators.assign(util::omp_util::get_num_threads(), std::mt19937());
+ this->root = alloc_.allocate(1);
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::reset()
+ {
+ alloc_.clear();
+ this->root = alloc_.allocate(1);
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::init_with_openings(const openings& o)
+ {
+ o.copy_to(this->root, alloc_);
+ }
+
+ template <typename Game>
+ node* mcts_two_players<Game>::select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent)
+ {
+ using namespace std;
+ const unsigned int N = parent->get_statistics().count;
+ const float log_of_N = fast_log_.log(N);
+ const uint16_t nb_children = parent->get_number_of_children();
+ uniform_int_distribution<uint16_t> d(0, nb_children - 1);
+ uint16_t k = d(generator);
+ double best_value_so_far = numeric_limits<double>::lowest();
+ uint16_t best_move_so_far = k;
+ node* const children = parent->get_children();
+ node* best_child_so_far = children + k;
+ unsigned int count;
+ float v;
+ for (uint16_t i = 0; i < nb_children; ++i)
+ {
+ node* child = children + k;
+ count = child->get_statistics().count;
+ v = -child->get_statistics().value + C_ * sqrt(log_of_N / count);
+ if (v > best_value_so_far)
+ {
+ best_value_so_far = v;
+ best_child_so_far = child;
+ best_move_so_far = k;
+ }
+ ++k;
+ if (k == nb_children) k = 0;
+ }
+ if (best_child_so_far->is_proven())
+ {
+ if (best_child_so_far->is_lost()) parent->set_won();
+ else
+ {
+ bool all_won = true;
+ for (uint16_t i = 0; i < nb_children; ++i)
+ {
+ node* child = children + i;
+ if (!child->is_won())
+ {
+ all_won = false;
+ break;
+ }
+ }
+ if (all_won) parent->set_lost();
+ }
+ }
+ game->play(best_move_so_far);
+ return best_child_so_far;
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::expand(const std::shared_ptr<Game>& game, node* n)
+ {
+ unsigned int count = n->get_statistics().count;
+ if (count >= nb_visits_before_expansion_ && !n->test_and_set())
+ {
+ unsigned int nb_children = game->number_of_moves();
+ node* children = alloc_.allocate(nb_children);
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ node* child = children + i;
+ child->get_statistics_ref().count = 1;
+ child->get_statistics_ref().value = 0;
+ }
+ n->set_children(children);
+ n->set_number_of_children(nb_children);
+ }
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::think(const std::shared_ptr<Game>& game)
+ {
+ using namespace std;
+ const chrono::steady_clock::time_point start = chrono::steady_clock::now();
+ chrono::steady_clock::time_point now;
+ mt19937& generator = mcts<Game>::generators[util::omp_util::get_thread_num()];
+ auto state = game->get_state();
+ vector<node*> visited(200);
+ vector<uint16_t> moves(200);
+ unsigned int nb_iter = 0;
+ do
+ {
+ int size = 1;
+ node* current = this->root;
+ visited[0] = current;
+ while (!game->end_of_game() && !current->is_leaf() && !current->is_proven())
+ {
+ current = select(game, generator, current);
+ visited[size++] = current;
+ }
+ int game_value = 0;
+ if (current->is_proven())
+ {
+ if (current->is_won()) game_value = 1;
+ else
+ {
+ game_value = -1;
+ }
+ }
+ else if (game->end_of_game())
+ {
+ int v = game->value_for_current_player();
+ if (v > 0)
+ {
+ game_value = 1;
+ if (new_version_) current->set_won();
+ }
+ else if (v < 0)
+ {
+ game_value = -1;
+ if (new_version_)
+ {
+ current->set_lost();
+ if (size > 1) visited[size - 2]->set_won();
+ }
+ }
+ }
+ else
+ {
+ uint8_t player = game->current_player();
+ expand(game, current);
+ game->playout(generator);
+ int v = game->value(player);
+ if (v > 0) game_value = 1;
+ else if (v < 0) game_value = -1;
+ }
+ for (int i = size - 1; i >= 0; --i)
+ {
+ visited[i]->update(game_value);
+ game_value = -game_value;
+ }
+ game->set_state(state);
+ ++nb_iter;
+ if ((nb_iter & 0x3F) == 0) now = chrono::steady_clock::now();
+ }
+ while ((nb_iter & 0x3F) != 0 || now < start + this->milliseconds);
+ }
+
+ template <typename Game>
+ uint16_t mcts_two_players<Game>::select_move()
+ {
+ using namespace std;
+ if (!this->root->is_proven())
+ {
+#pragma omp parallel
+ think(game::copy(this->game));
+ }
+ // std::ofstream ofs ("graph.gv", ofstream::out);
+ // util::display_node::node_to_dot(ofs, this->root, 1000, 50);
+ util::display_node::node_to_ascii(cout, this->root, 2);
+ // std::cout << "finished " << new_version_ << std::endl;
+ // string _;
+ // getline(cin, _);
+ unsigned int best_count_so_far = 0;
+ uint16_t nb_children = this->root->get_number_of_children();
+ uniform_int_distribution<uint16_t> d(0, nb_children - 1);
+ uint16_t k = d(this->generators[0]);
+ uint16_t best_move_so_far = k;
+ node* children = this->root->get_children();
+ unsigned int c;
+ for (uint16_t i = 0; i < nb_children; ++i)
+ {
+ node *child = children + k;
+ if (child->is_lost())
+ {
+ best_move_so_far = k;
+ break;
+ }
+ c = children[k].get_statistics().count;
+ if (c > best_count_so_far)
+ {
+ best_count_so_far = c;
+ best_move_so_far = k;
+ }
+ ++k;
+ if (k == nb_children) k = 0;
+ }
+ return best_move_so_far;
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::last_moves(uint16_t computer, uint16_t other)
+ {
+ if (this->root->is_leaf() || this->root->get_children()[computer].is_leaf())
+ {
+ alloc_.clear();
+ this->root = alloc_.allocate(1);
+ }
+ else
+ {
+ this->root = alloc_.move(&this->root->get_children()[computer].get_children()[other]);
+ }
+ }
+
+ template <typename Game>
+ void mcts_two_players<Game>::last_move(uint16_t move)
+ {
+ if (this->root->is_leaf())
+ {
+ alloc_.clear();
+ this->root = alloc_.allocate(1);
+ }
+ else
+ {
+ this->root = alloc_.move(&this->root->get_children()[move]);
+ }
+ }
+
+}
+
+#endif
diff --git a/src/mcts/node.cpp b/src/mcts/node.cpp
new file mode 100644
index 0000000..bc40789
--- /dev/null
+++ b/src/mcts/node.cpp
@@ -0,0 +1,24 @@
+#include "node.hpp"
+#include <sstream>
+#include "display_node.hpp"
+
+using namespace std;
+
+namespace mcts
+{
+ string node::to_string() const
+ {
+ stringbuf buffer;
+ ostream os(&buffer);
+ util::display_node::node_to_ascii(os, this);
+ os << endl;
+ return buffer.str();
+ }
+
+ ostream& operator<<(ostream& os, const node& n)
+ {
+ util::display_node::node_to_ascii(os, &n);
+ os << endl;
+ return os;
+ }
+}
diff --git a/src/mcts/node.hpp b/src/mcts/node.hpp
new file mode 100644
index 0000000..591e6df
--- /dev/null
+++ b/src/mcts/node.hpp
@@ -0,0 +1,138 @@
+#ifndef __NODE_HPP__
+#define __NODE_HPP__
+
+#include "statistics.hpp"
+#include <string>
+#include <iostream>
+#include <limits>
+
+#define NODE_WON_VALUE 1e15
+#define NODE_LOST_VALUE -1e15
+
+namespace mcts
+{
+ class node
+ {
+ statistics stats;
+ bool flag = false;
+ uint16_t number_of_children = 0;
+ node* children = nullptr;
+
+ public:
+ inline uint16_t get_winning_index() const;
+ inline bool is_leaf() const;
+ inline uint16_t get_number_of_children() const;
+ inline node* get_children() const;
+ inline void set_number_of_children(uint16_t n);
+ inline void set_children(node* n);
+ inline void set_won();
+ inline void set_lost();
+ inline bool is_proven() const;
+ inline bool is_won() const;
+ inline bool is_lost() const;
+ inline const statistics& get_statistics() const;
+ inline statistics& get_statistics_ref();
+ inline void set_statistics(const statistics& s);
+ inline bool test_and_set();
+ inline void update(int value);
+ inline void update_count();
+ std::string to_string() const;
+ friend std::ostream& operator<<(std::ostream& os, const node& n);
+ };
+
+ bool node::is_proven() const
+ {
+ return is_won() || is_lost();
+ }
+
+ void node::set_won()
+ {
+ stats.value = NODE_WON_VALUE;
+ }
+
+ void node::set_lost()
+ {
+ stats.value = NODE_LOST_VALUE;
+ }
+
+ bool node::is_won() const
+ {
+ return stats.value > 1.1;
+ }
+
+ bool node::is_lost() const
+ {
+ return stats.value < -1.1;
+ }
+
+ bool node::is_leaf() const
+ {
+ return get_number_of_children() == 0 || get_children() == nullptr;
+ }
+
+ uint16_t node::get_number_of_children() const
+ {
+ uint16_t res;
+#pragma omp atomic read
+ res = number_of_children;
+ return res;
+ }
+ node* node::get_children() const
+ {
+ node* res;
+#pragma omp atomic read
+ res = children;
+ return res;
+ }
+ void node::set_number_of_children(uint16_t n)
+ {
+#pragma omp atomic write
+ number_of_children = n;
+ }
+ void node::set_children(node* n)
+ {
+#pragma omp atomic write
+ children = n;
+ }
+ const statistics& node::get_statistics() const
+ {
+ return stats;
+ }
+ statistics& node::get_statistics_ref()
+ {
+ return stats;
+ }
+ void node::set_statistics(const statistics& s)
+ {
+ stats = s;
+ }
+ bool node::test_and_set()
+ {
+ bool res;
+#pragma GCC diagnostic ignored "-Wunused-value"
+#pragma omp atomic capture
+ {
+ res = flag;
+ flag = true;
+ }
+ return res;
+ }
+
+ void node::update_count()
+ {
+ ++stats.count;
+ }
+
+ void node::update(int v)
+ {
+ unsigned int count = stats.count;
+ double value = stats.value;
+ ++count;
+ value += (v - value) / count;
+ stats.value = value;
+ stats.count = count;
+ }
+
+}
+
+#endif
diff --git a/src/mcts/openings.cpp b/src/mcts/openings.cpp
new file mode 100644
index 0000000..e139c7d
--- /dev/null
+++ b/src/mcts/openings.cpp
@@ -0,0 +1,30 @@
+#include "openings.hpp"
+
+namespace mcts
+{
+ std::ostream& operator<<(std::ostream& os, const openings& op)
+ {
+ util::display_node::node_to_ascii(os, op.root_, 3);
+ return os;
+ }
+
+ void openings::copy_to(node* root, allocator& alloc) const
+ {
+ copy(root_, root, alloc);
+ }
+
+ void openings::copy(node* src, node* dst, allocator& alloc) const
+ {
+ dst->set_statistics(src->get_statistics());
+ const unsigned int nb_children = src->get_number_of_children();
+ dst->set_number_of_children(nb_children);
+ if (nb_children == 0) return;
+ dst->set_children(alloc.allocate(nb_children));
+ node* const src_children = src->get_children();
+ node* const dst_children = dst->get_children();
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ copy(src_children + i, dst_children + i, alloc);
+ }
+ }
+}
diff --git a/src/mcts/openings.hpp b/src/mcts/openings.hpp
new file mode 100644
index 0000000..94e0c79
--- /dev/null
+++ b/src/mcts/openings.hpp
@@ -0,0 +1,115 @@
+#ifndef __OPENINGS_HPP__
+#define __OPENINGS_HPP__
+
+#include "allocator.hpp"
+#include <vector>
+#include "display_node.hpp"
+
+namespace mcts
+{
+ class openings
+ {
+ allocator alloc_;
+ node* root_;
+ const unsigned int nb_visits_before_expansion_;
+
+ void copy(node* src, node* dst, allocator& alloc) const;
+ template <typename Game>
+ void expand(Game& game, node* n, uint16_t move, int value);
+ public:
+ template <typename Game>
+ openings(const Game& game, unsigned int nb_visits_before_expansion = 2);
+ void copy_to(node* root, allocator& alloc) const;
+ template <typename Game>
+ void update(Game& game, const std::vector<uint16_t>& moves, int value);
+ friend std::ostream& operator<<(std::ostream& os, const openings& op);
+ };
+
+ template <typename Game>
+ openings::openings(const Game& game, unsigned int nb_visits_before_expansion) : nb_visits_before_expansion_(nb_visits_before_expansion)
+ {
+ root_ = alloc_.allocate(1);
+ unsigned int nb_children = game.number_of_moves();
+ node* children = alloc_.allocate(nb_children);
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ node* child = children + i;
+ child->get_statistics_ref().count = 1;
+ child->get_statistics_ref().value = 0;
+ }
+ }
+
+ template <typename Game>
+ void openings::expand(Game& game, node* n, uint16_t move, int value)
+ {
+ unsigned int count = n->get_statistics().count;
+ if (count >= nb_visits_before_expansion_)
+ {
+ unsigned int nb_children = game.number_of_moves();
+ node* children = alloc_.allocate(nb_children);
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ node* child = children + i;
+ child->get_statistics_ref().count = 1;
+ child->get_statistics_ref().value = 0;
+ }
+ n->set_children(children);
+ n->set_number_of_children(nb_children);
+ children[move].update(value);
+ }
+ }
+
+ template <typename Game>
+ void openings::update(Game& game, const std::vector<uint16_t>& moves, int value)
+ {
+ node* pred = nullptr;
+ node* current = root_;
+ int k = 0;
+ while (true)
+ {
+ current->update(value);
+ value = -value;
+ if (current->is_leaf()) break;
+ uint16_t m = moves[k++];
+ game.play(m);
+ pred = current;
+ current = current->get_children() + m;
+ if (current->is_proven())
+ {
+ if (current->is_lost()) pred->set_won();
+ else
+ {
+ const uint16_t nb_children = pred->get_number_of_children();
+ node* const children = pred->get_children();
+ bool all_won = true;
+ for (uint16_t i = 0; i < nb_children; ++i)
+ {
+ node* child = children + i;
+ if (!child->is_won())
+ {
+ all_won = false;
+ break;
+ }
+ }
+ if (all_won) pred->set_lost();
+ }
+ return;
+ }
+ }
+ if (!game.end_of_game())
+ {
+ expand(game, current, moves[k], value);
+ }
+ else
+ {
+ if (value == 1) current->set_won();
+ else if (value == -1)
+ {
+ current->set_lost();
+ if (pred != nullptr) pred->set_won();
+ }
+ }
+ }
+}
+
+#endif
diff --git a/src/mcts/statistics.cpp b/src/mcts/statistics.cpp
new file mode 100644
index 0000000..cafa2ad
--- /dev/null
+++ b/src/mcts/statistics.cpp
@@ -0,0 +1,16 @@
+#include "statistics.hpp"
+#include <sstream>
+#include <iomanip>
+
+using namespace std;
+
+namespace mcts
+{
+ std::string statistics::to_string() const
+ {
+ stringbuf buffer;
+ ostream os(&buffer);
+ os << "(count: " << count << ", value: " << setprecision(2) << value << ")";
+ return buffer.str();
+ }
+}
diff --git a/src/mcts/statistics.hpp b/src/mcts/statistics.hpp
new file mode 100644
index 0000000..78dfa69
--- /dev/null
+++ b/src/mcts/statistics.hpp
@@ -0,0 +1,16 @@
+#ifndef __STATISTICS_HPP__
+#define __STATISTICS_HPP__
+
+#include <string>
+
+namespace mcts
+{
+ struct statistics
+ {
+ unsigned int count = 0;
+ float value = 0;
+ std::string to_string() const;
+ };
+}
+
+#endif
diff --git a/src/mcts/test_allocator.cpp b/src/mcts/test_allocator.cpp
new file mode 100644
index 0000000..98f70cd
--- /dev/null
+++ b/src/mcts/test_allocator.cpp
@@ -0,0 +1,109 @@
+#include "test_allocator.hpp"
+#include <algorithm>
+#include "pow.hpp"
+#include <iostream>
+//#include <thread>
+#include <random>
+#include "display_node.hpp"
+
+using namespace std;
+
+namespace mcts
+{
+ test_allocator::test_allocator(unsigned int depth, unsigned int nb_children)
+ {
+ allocate(depth, nb_children);
+ allocate_multi_threaded(depth, nb_children);
+ alloc.clear();
+ allocate(depth, nb_children);
+ allocate_multi_threaded(depth, nb_children);
+ alloc.clear();
+ node* root = alloc.allocate(1);
+ build(depth, nb_children, root);
+ cout << "size: " << alloc.size() << endl;
+ cout << "free space: " << alloc.free_space() << endl;
+ cout << root << endl << *root << endl;
+ util::display_node::node_to_dot(cout, root);
+ node* new_root = alloc.move(root);
+ cout << "free space: " << alloc.free_space() << endl;
+ cout << new_root << endl << *new_root << endl;
+ }
+
+ void test_allocator::build(unsigned int depth, unsigned int nb_children, node* n)
+ {
+ uniform_int_distribution<int> dint(1, nb_children);
+ statistics& stats = n->get_statistics_ref();
+ stats.count = dint(generator);
+ uniform_real_distribution<float> dfloat(-1, 1);
+ stats.value = dfloat(generator);
+ if (depth == 0) return;
+ node* children = alloc.allocate(nb_children);
+ n->set_children(children);
+ n->set_number_of_children(nb_children);
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ build(depth - 1, nb_children, children + i);
+ }
+ }
+
+ void test_allocator::collect(vector<node*>& nodes, node* n)
+ {
+ if (n == nullptr) return;
+ nodes.push_back(n);
+ uint16_t nb_children = n->get_number_of_children();
+ node* children = n->get_children();
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ collect(nodes, children + i);
+ }
+ }
+
+ bool test_allocator::check(vector<node*> nodes, unsigned int depth, unsigned int nb_children)
+ {
+ if ((int)nodes.size() != 1 + (util::pow_l(nb_children, depth + 1) - nb_children) / (nb_children - 1)) return false;
+ sort(nodes.begin(), nodes.end());
+ for (unsigned int i = 1; i < nodes.size(); ++i)
+ {
+ if (nodes[i-1] + 1 != nodes[i]) return false;
+ }
+ return true;
+ }
+
+ void test_allocator::test(node* root, unsigned int depth, unsigned int nb_children, const string& msg)
+ {
+ vector<node*> nodes;
+ collect(nodes, root);
+ if (check(nodes, depth, nb_children)) std::cout << msg + " succeeded" << std::endl;
+ else std::cout << msg + " failed" << std::endl;
+ }
+
+ void test_allocator::allocate(unsigned int depth, unsigned int nb_children)
+ {
+ node* root = alloc.allocate(1);
+ build(depth, nb_children, root);
+ test(root, depth, nb_children, "allocate");
+ }
+
+ void test_allocator::allocate_multi_threaded(unsigned int depth, unsigned int nb_children)
+ {
+ node* root = alloc.allocate(1);
+ if (depth != 0)
+ {
+ root->set_number_of_children(nb_children);
+ node* children = alloc.allocate(nb_children);
+ root->set_children(children);
+ // vector<thread> threads;
+ // for (unsigned int i = 0; i < nb_children; ++i)
+ // {
+ // threads.push_back(thread(&test_allocator::build, this, depth - 1, nb_children, children + i));
+ // }
+ // for_each(threads.begin(), threads.end(), mem_fn(&thread::join));
+#pragma omp parallel for
+ for (unsigned int i = 0; i < nb_children; ++i)
+ {
+ build(depth - 1, nb_children, children + i);
+ }
+ }
+ test(root, depth, nb_children, "allocate multi threaded");
+ }
+}
diff --git a/src/mcts/test_allocator.hpp b/src/mcts/test_allocator.hpp
new file mode 100644
index 0000000..3e141c2
--- /dev/null
+++ b/src/mcts/test_allocator.hpp
@@ -0,0 +1,29 @@
+#ifndef __TEST_ALLOCATOR_HPP__
+#define __TEST_ALLOCATOR_HPP__
+
+#include "allocator.hpp"
+#include <vector>
+#include <string>
+#include <random>
+
+namespace mcts
+{
+ class test_allocator
+ {
+ allocator alloc;
+ std::default_random_engine generator;
+
+ void allocate(unsigned int depth, unsigned int nb_children);
+ void allocate_multi_threaded(unsigned int depth, unsigned int nb_children);
+ void build(unsigned int depth, unsigned int nb_children, node* n);
+ void collect(std::vector<node*>& nodes, node* n);
+ bool check(std::vector<node*> nodes, unsigned int depth, unsigned int nb_children);
+ void test(node* root, unsigned int depth, unsigned int nb_children, const std::string& msg);
+
+ public:
+ test_allocator(unsigned int depth = 3, unsigned int nb_children = 2);
+ std::string to_string() const;
+ };
+}
+
+#endif
diff --git a/src/mcts/test_mcts_two_players.cpp b/src/mcts/test_mcts_two_players.cpp
new file mode 100644
index 0000000..dbe95ec
--- /dev/null
+++ b/src/mcts/test_mcts_two_players.cpp
@@ -0,0 +1,280 @@
+#include "mcts_two_players.hpp"
+#include "test_mcts_two_players.hpp"
+#include "connect4.hpp"
+#include <iostream>
+#include <iomanip>
+#include <map>
+
+//#include <gperftools/profiler.h>
+
+using namespace std;
+using namespace game;
+
+namespace mcts
+{
+ test_mcts_two_players::test_mcts_two_players() : openings_(connect4())
+ {
+ //self_play(1000);
+ play();
+ //test_openings(10000, 1000);
+ }
+
+ void test_mcts_two_players::test_openings(int nb_learning, int nb_testing)
+ {
+ // self_play(nb_testing);
+ self_play_learn_openings(nb_learning);
+ self_play(nb_testing, true);
+ }
+
+ template <typename Game>
+ int test_mcts_two_players::select_move(Game& game)
+ {
+ cout << game.player_to_string(game.current_player()) << " move: ";
+ map<string, int> m;
+ for (int i = 0; i < game.number_of_moves(); ++i)
+ {
+ m[game.move_to_string(i)] = i;
+ }
+ string move;
+ getline(cin, move);
+ game.play(m[move]);
+ return m[move];
+ }
+
+ void test_mcts_two_players::play()
+ {
+ // ProfilerStart("theturk.prof");
+ connect4 c4;
+ auto the_turk = make_mcts_two_players(c4, 5000, 0.3, 4);
+ cout << "play one game" << endl;
+ cout << "who's first? (h)uman/(c)omputer ";
+ string ans;
+ getline(cin, ans);
+ cout << c4 << endl;
+ int human_last_move = -1, computer_last_move = -1;
+ while (!c4.end_of_game())
+ {
+ if ((ans == "h" && c4.current_player() == 0) || (ans == "c" && c4.current_player() == 1))
+ {
+ human_last_move = select_move(c4);
+ }
+ else
+ {
+ if (human_last_move != -1 && computer_last_move != -1)
+ {
+ the_turk.last_moves(computer_last_move, human_last_move);
+ }
+ uint16_t move = the_turk.select_move();
+ computer_last_move = move;
+ cout << c4.player_to_string(c4.current_player()) << " move: " << c4.move_to_string(move) << endl;
+ c4.play(move);
+ }
+ cout << c4 << endl;
+ }
+ if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
+ else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
+ else cout << "draw";
+ cout << endl;
+ // ProfilerStop();
+ }
+
+ void test_mcts_two_players::self_play_learn_openings(int n)
+ {
+ connect4 c4;
+ vector<uint16_t> moves(200);
+ auto state = c4.get_state();
+ auto the_turk_1 = make_mcts_two_players(c4, 1000, 0.6, 2);
+ auto the_turk_2 = make_mcts_two_players(c4, 1000, 0.6, 2);
+ map<set<int>, pair<uint32_t, double>> learning_examples;
+ for (int i = 0; i < n; ++i)
+ {
+ cout << i << endl;
+ cout << openings_ << endl << endl;
+ moves.clear();
+ c4.set_state(state);
+ the_turk_1.reset();
+ the_turk_1.init_with_openings(openings_);
+ the_turk_2.reset();
+ the_turk_2.init_with_openings(openings_);
+ int the_turk_1_last_move = -1, the_turk_2_last_move = -1;
+ int k = 0;
+ while (!c4.end_of_game())
+ {
+ if (k == 1) the_turk_2.last_move(the_turk_1_last_move);
+ if (k % 2 == 0)
+ {
+ if (the_turk_2_last_move != -1)
+ {
+ the_turk_1.last_moves(the_turk_1_last_move, the_turk_2_last_move);
+ }
+ uint16_t move = the_turk_1.select_move();
+ moves.push_back(move);
+ the_turk_1_last_move = move;
+ c4.play(move);
+ }
+ else
+ {
+ if (the_turk_2_last_move != -1)
+ {
+ the_turk_2.last_moves(the_turk_2_last_move, the_turk_1_last_move);
+ }
+ uint16_t move = the_turk_2.select_move();
+ moves.push_back(move);
+ the_turk_2_last_move = move;
+ c4.play(move);
+ }
+ ++k;
+ }
+ std::cout << c4 << std::endl;
+ int v = c4.value(0);
+ cout << "value for first player " << v << endl;
+ c4.set_state(state);
+ openings_.update(c4, moves, v);
+ c4.set_state(state);
+ for (uint16_t m : moves)
+ {
+ c4.play(m);
+ v = -v;
+ set<int> input_vector = std::move(c4.to_input_vector());
+ auto it = learning_examples.find(input_vector);
+ if (it == learning_examples.end())
+ {
+ learning_examples[input_vector] = make_pair(1, v);
+ }
+ else
+ {
+ it->second.second = (it->second.second * it->second.first + v) / (it->second.first + 1);
+ it->second.first += 1;
+ }
+ }
+ }
+ cout << "number of learning examples: " << learning_examples.size() << endl;
+ ofstream output("learning_examples.txt");
+ for (const auto& example : learning_examples)
+ {
+ output << example.second.second;
+ for (int index : example.first)
+ {
+ output << " " << index << ":" << 1;
+ }
+ output << endl;
+ }
+ output.close();
+ }
+
+ void test_mcts_two_players::self_play(int n, bool with_openings)
+ {
+ connect4 c4;
+ auto state = c4.get_state();
+ auto the_turk_v1 = make_mcts_two_players(c4, 1000, 0.6, 2);
+ auto the_turk_v2 = make_mcts_two_players(c4, 1000, 0.6, 2);
+ int nb_win_v1 = 0, nb_win_v2 = 0, nb_draw = 0;
+ for (int i = 0; i < n; ++i)
+ {
+ cout << i << endl;
+ c4.set_state(state);
+ the_turk_v1.reset();
+ the_turk_v2.reset();
+ if (with_openings) the_turk_v2.init_with_openings(openings_);
+ int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
+ int k = 0;
+ while (!c4.end_of_game())
+ {
+ if (with_openings && k == 1 && i % 2 == 0) the_turk_v2.last_move(the_turk_v1_last_move);
+ ++k;
+ // cout << c4 << endl;
+ if ((i % 2 == 0 && c4.current_player() == 0) || (i % 2 == 1 && c4.current_player() == 1))
+ {
+ if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
+ {
+ the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
+ }
+ uint16_t move = the_turk_v1.select_move();
+ the_turk_v1_last_move = move;
+ c4.play(move);
+ }
+ else
+ {
+ if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
+ {
+ the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
+ }
+ uint16_t move = the_turk_v2.select_move();
+ the_turk_v2_last_move = move;
+ c4.play(move);
+ }
+ }
+ if (c4.value(0) == 1)
+ {
+ if (i % 2 == 0)
+ {
+ /*cout << "v1 won" << endl;*/ ++nb_win_v1;
+ }
+ else
+ {
+ /*cout << "v2 won" << endl;*/ ++nb_win_v2;
+ }
+ }
+ else if (c4.value(1) == 1)
+ {
+ if (i % 2 == 0)
+ {
+ /*cout << "v2 won" << endl;*/ ++nb_win_v2;
+ }
+ else
+ {
+ /*cout << "v1 won" << endl;*/ ++nb_win_v1;
+ }
+ }
+ else
+ {
+ /*cout << "draw" << endl;*/ ++nb_draw;
+ }
+ cout << setw(10) << "v1 nb wins: " << nb_win_v1 << " v2 nb wins: " << nb_win_v2 << " nb draws: " << nb_draw << endl;
+ }
+ }
+
+ void test_mcts_two_players::self_play()
+ {
+ connect4 c4;
+ auto the_turk_v1 = make_mcts_two_players(c4, 1000, 1.2, 2);
+ auto the_turk_v2 = make_mcts_two_players(c4, 1000, 1.2, 2);
+ cout << "play one game" << endl;
+ cout << "who's first? the_turk_(v1)/the_turk_(v2) ";
+ string ans;
+ getline(cin, ans);
+ cout << c4 << endl;
+ int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
+ while (!c4.end_of_game())
+ {
+ if ((ans == "v1" && c4.current_player() == 0) || (ans == "v2" && c4.current_player() == 1))
+ {
+ if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
+ {
+ the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
+ }
+ uint16_t move = the_turk_v1.select_move();
+ the_turk_v1_last_move = move;
+ cout << c4.player_to_string(c4.current_player()) << " move: " << c4.move_to_string(move) << endl;
+ c4.play(move);
+ }
+ else
+ {
+ if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
+ {
+ the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
+ }
+ uint16_t move = the_turk_v2.select_move();
+ the_turk_v2_last_move = move;
+ cout << c4.player_to_string(c4.current_player()) << " move: " << c4.move_to_string(move) << endl;
+ c4.play(move);
+ }
+ cout << c4 << endl;
+ }
+ if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
+ else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
+ else cout << "draw";
+ cout << endl;
+ }
+
+}
diff --git a/src/mcts/test_mcts_two_players.hpp b/src/mcts/test_mcts_two_players.hpp
new file mode 100644
index 0000000..c04f71f
--- /dev/null
+++ b/src/mcts/test_mcts_two_players.hpp
@@ -0,0 +1,25 @@
+#ifndef __TEST_MCTS_TWO_PLAYERS_HPP__
+#define __TEST_MCTS_TWO_PLAYERS_HPP__
+
+#include "openings.hpp"
+
+namespace mcts
+{
+ class test_mcts_two_players
+ {
+ openings openings_;
+
+ void play();
+ void self_play();
+ void self_play(int n, bool with_openings = false);
+ void self_play_learn_openings(int n);
+ void test_openings(int nb_learning, int nb_testing);
+
+ template <typename Game>
+ int select_move(Game& game);
+ public:
+ test_mcts_two_players();
+ };
+}
+
+#endif
diff --git a/src/minmax/connect4_heuristic.cpp b/src/minmax/connect4_heuristic.cpp
new file mode 100644
index 0000000..25ad3a6
--- /dev/null
+++ b/src/minmax/connect4_heuristic.cpp
@@ -0,0 +1,11 @@
+#include "connect4_heuristic.hpp"
+
+namespace minmax
+{
+ double connect4_heuristic::value(const connect4& c4) const
+ {
+ const connect4_state& state = c4.get_state();
+ return 0;
+ }
+
+}
diff --git a/src/minmax/connect4_heuristic.hpp b/src/minmax/connect4_heuristic.hpp
new file mode 100644
index 0000000..050d176
--- /dev/null
+++ b/src/minmax/connect4_heuristic.hpp
@@ -0,0 +1,14 @@
+#ifndef __CONNECT4_HEURISTIC_HPP__
+#define __CONNECT4_HEURISTIC_HPP__
+
+#include <connect4.hpp>
+
+namespace minmax
+{
+ class connect4_heuristic : public heuristic<connect4>
+ {
+ double value(const connect4& c4) const;
+ };
+}
+
+#endif
diff --git a/src/minmax/heuristic.hpp b/src/minmax/heuristic.hpp
new file mode 100644
index 0000000..09803f0
--- /dev/null
+++ b/src/minmax/heuristic.hpp
@@ -0,0 +1,26 @@
+#ifndef __HEURISTIC_HPP__
+#define __HEURISTIC_HPP__
+
+namespace minmax
+{
+ template <typename Game>
+ class heuristic
+ {
+ public:
+ virtual double value(const Game& game) const = 0;
+ };
+
+ template <typename Game>
+ class null_heuristic : public heuristic<Game>
+ {
+ double value(const Game& game) const;
+ };
+
+ template <typename Game>
+ double null_heuristic<Game>::value(const Game& game) const
+ {
+ return 0;
+ }
+}
+
+#endif
diff --git a/src/minmax/minmax.hpp b/src/minmax/minmax.hpp
new file mode 100644
index 0000000..6a77f7c
--- /dev/null
+++ b/src/minmax/minmax.hpp
@@ -0,0 +1,135 @@
+#ifndef __MINMAX_HPP__
+#define __MINMAX_HPP__
+
+#include <chrono>
+#include <vector>
+#include "game.hpp"
+#include "heuristic.hpp"
+#include <iostream>
+#include <limits>
+
+namespace minmax
+{
+ struct cannot_prove : std::exception
+ {
+ const char* what() const noexcept { return "cannot prove the game theoritical value"; }
+ };
+
+ template <typename Game>
+ class minmax
+ {
+ protected:
+ Game& game;
+ std::chrono::milliseconds milliseconds;
+ const heuristic<Game>& h;
+ std::vector<uint16_t> principal_variation;
+ std::chrono::steady_clock::time_point start;
+
+ public:
+ minmax(Game& game, uint32_t milliseconds, const heuristic<Game>& h = null_heuristic<Game>())
+ : game(game), milliseconds(milliseconds), h(h)
+ {
+ }
+
+ int prove();
+ double solve();
+ uint16_t select_move();
+
+ private:
+ long prove(int depth);
+ double solve(int depth);
+ };
+
+ template <typename Game>
+ minmax<Game> make_minmax(Game& game, uint32_t milliseconds, const heuristic<Game>& h = null_heuristic<Game>())
+ {
+ return minmax<Game>(game, milliseconds, h);
+ }
+
+ template <typename Game>
+ double minmax<Game>::solve()
+ {
+ return 0;
+ }
+
+ template <typename Game>
+ double minmax<Game>::solve(int depth)
+ {
+ return 0;
+ }
+
+ template <typename Game>
+ uint16_t minmax<Game>::select_move()
+ {
+ return 0;
+ }
+
+ const long UNKNOWN = std::numeric_limits<long>::max();
+
+ template <typename Game>
+ int minmax<Game>::prove()
+ {
+ start = std::chrono::steady_clock::now();
+ uint16_t nb_moves = game.number_of_moves();
+ long value[nb_moves];
+ std::fill_n(value, nb_moves, UNKNOWN);
+ int depth = 3;
+ auto state = game.get_state();
+ try
+ {
+ int nb_proved_moves = 0, nb_draws = 0;
+ while (true)
+ {
+ for (uint16_t move = 0; move < nb_moves; ++move)
+ {
+ if (value[move] != UNKNOWN) continue;
+ game.play(move);
+ value[move] = prove(depth);
+ game.set_state(state);
+ if (value[move] == -1) return 1;
+ if (value[move] == 0) ++nb_draws;
+ if (value[move] != UNKNOWN) ++nb_proved_moves;
+ }
+ if (nb_proved_moves == nb_moves)
+ {
+ if (nb_draws != 0) return 0;
+ return -1;
+ }
+ ++depth;
+ }
+ }
+ catch (cannot_prove fail)
+ {
+ game.set_state(state);
+ }
+ throw cannot_prove();
+ }
+
+ template <typename Game>
+ long minmax<Game>::prove(int depth)
+ {
+ if (game.end_of_game()) return game.value(game.current_player());
+ if (depth == 0) return UNKNOWN;
+ if ((depth & 3) && std::chrono::steady_clock::now() >= start + milliseconds) throw cannot_prove();
+ uint16_t nb_moves = game.number_of_moves();
+ auto state = game.get_state();
+ int nb_proved_moves = 0, nb_draws = 0;
+ for (uint16_t move = 0; move < nb_moves; ++move)
+ {
+ game.play(move);
+ long v = prove(depth - 1);
+ game.set_state(state);
+ if (v == -1) return 1;
+ if (v == 0) ++nb_draws;
+ if (v != UNKNOWN) ++nb_proved_moves;
+ }
+ if (nb_proved_moves == nb_moves)
+ {
+ if (nb_draws != 0) return 0;
+ return -1;
+ }
+ return UNKNOWN;
+ }
+}
+
+#endif
diff --git a/src/minmax/test_minmax.cpp b/src/minmax/test_minmax.cpp
new file mode 100644
index 0000000..7d5aa9c
--- /dev/null
+++ b/src/minmax/test_minmax.cpp
@@ -0,0 +1,67 @@
+#include "minmax.hpp"
+#include "test_minmax.hpp"
+#include "connect4.hpp"
+#include <iostream>
+#include <iomanip>
+#include <map>
+
+using namespace std;
+using namespace game;
+
+namespace minmax
+{
+ test_minmax::test_minmax()
+ {
+ play();
+ }
+
+ template <typename Game>
+ int test_minmax::select_move(Game& game)
+ {
+ cout << game.player_to_string(game.current_player()) << " move: ";
+ map<string, int> m;
+ for (int i = 0; i < game.number_of_moves(); ++i)
+ {
+ m[game.move_to_string(i)] = i;
+ }
+ string move;
+ getline(cin, move);
+ game.play(m[move]);
+ return m[move];
+ }
+
+ void test_minmax::play()
+ {
+ connect4 c4;
+ auto minimax = make_minmax(c4, 2000);
+ cout << "play one game" << endl;
+ cout << c4 << endl;
+ while (!c4.end_of_game())
+ {
+ cout << "try to prove? (y/n)" << endl;
+ string ans;
+ getline(cin, ans);
+ if (ans == "y")
+ {
+ try
+ {
+ int v = minimax.prove();
+ if (v == 1) cout << "won position" << endl;
+ if (v == -1) cout << "lost position" << endl;
+ if (v == 0) cout << "drawn position" << endl;
+ }
+ catch (exception fail)
+ {
+ cout << "unable to prove" << endl;
+ }
+ }
+ select_move(c4);
+ cout << c4 << endl;
+ }
+ if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
+ else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
+ else cout << "draw";
+ cout << endl;
+ }
+
+}
diff --git a/src/minmax/test_minmax.hpp b/src/minmax/test_minmax.hpp
new file mode 100644
index 0000000..7d8fe99
--- /dev/null
+++ b/src/minmax/test_minmax.hpp
@@ -0,0 +1,16 @@
+#ifndef __TEST_MINMAX_HPP__
+#define __TEST_MINMAX_HPP__
+
+namespace minmax
+{
+ class test_minmax
+ {
+ void play();
+ template <typename Game>
+ int select_move(Game& game);
+ public:
+ test_minmax();
+ };
+}
+
+#endif
diff --git a/src/monte_carlo/monte_carlo.cpp b/src/monte_carlo/monte_carlo.cpp
new file mode 100644
index 0000000..eee0301
--- /dev/null
+++ b/src/monte_carlo/monte_carlo.cpp
@@ -0,0 +1,12 @@
+#include "monte_carlo.hpp"
+#include "omp_util.hpp"
+#include <chrono>
+#include <limits>
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+namespace monte_carlo
+{
+}
diff --git a/src/monte_carlo/monte_carlo.hpp b/src/monte_carlo/monte_carlo.hpp
new file mode 100644
index 0000000..299d2fd
--- /dev/null
+++ b/src/monte_carlo/monte_carlo.hpp
@@ -0,0 +1,95 @@
+#ifndef __MONTE_CARLO_HPP__
+#define __MONTE_CARLO_HPP__
+
+#include "game.hpp"
+#include <random>
+#include <chrono>
+#include <vector>
+#include "omp_util.hpp"
+#include <iostream>
+#include <algorithm>
+
+namespace monte_carlo
+{
+ template <typename Game>
+ class monte_carlo
+ {
+ Game& game;
+ uint32_t batch_size;
+ std::chrono::milliseconds milliseconds;
+ std::vector<std::mt19937> generators;
+
+ public:
+ monte_carlo(Game& game, uint32_t batch_size, uint32_t milliseconds);
+ uint16_t select_move();
+ };
+
+ template <typename Game>
+ uint16_t monte_carlo<Game>::select_move()
+ {
+ using namespace std;
+ uint8_t current_player = game.current_player();
+ uint16_t nb_moves = game.number_of_moves();
+ vector<int> values(game.number_of_moves(), 0);
+ const chrono::steady_clock::time_point start = chrono::steady_clock::now();
+ chrono::steady_clock::time_point now;
+ vector<shared_ptr<Game>> games(util::omp_util::get_num_threads(), nullptr);
+ transform(games.begin(), games.end(), games.begin(), [this](const shared_ptr<Game>& _){ return game::copy(game); });
+ do
+ {
+#pragma omp parallel for
+ for (uint16_t move = 0; move < nb_moves; ++move)
+ {
+ int thread_num = util::omp_util::get_thread_num();
+ mt19937& generator = generators[thread_num];
+ shared_ptr<Game> g = games[thread_num];
+ for (uint32_t i = 0; i < batch_size; ++i)
+ {
+ auto state = g->get_state();
+ g->play(move);
+ g->playout(generator);
+ values[move] += g->value(current_player);
+ g->set_state(state);
+ }
+ }
+ now = chrono::steady_clock::now();
+ // cout << chrono::duration_cast<chrono::milliseconds>(now - start).count() << endl;
+ }
+ while (now < start + milliseconds);
+
+ int best_value_so_far = numeric_limits<int>::min();
+ uint16_t best_move_so_far = -1;
+ for (uint16_t move = 0; move < nb_moves; ++move)
+ {
+ cout << "(" << game.move_to_string(move) << ", " << values[move] << ") ";
+ if (values[move] > best_value_so_far)
+ {
+ best_value_so_far = values[move];
+ best_move_so_far = move;
+ }
+ }
+ cout << endl;
+ return best_move_so_far;
+ }
+
+ template <typename Game>
+ monte_carlo<Game> make_monte_carlo(Game& game, uint32_t batch_size, uint32_t milliseconds)
+ {
+ return monte_carlo<Game>(game, batch_size, milliseconds);
+ }
+
+ template <typename Game>
+ monte_carlo<Game>::monte_carlo(Game& game, uint32_t batch_size, uint32_t milliseconds)
+ : game(game), batch_size(batch_size), milliseconds(milliseconds)
+ {
+ using namespace std;
+ int num_threads = util::omp_util::get_num_threads();
+ for (int i = 0; i < num_threads; ++i)
+ {
+ generators.push_back(mt19937(chrono::system_clock::now().time_since_epoch().count()));
+ }
+ }
+
+}
+
+#endif
diff --git a/src/monte_carlo/test_monte_carlo.cpp b/src/monte_carlo/test_monte_carlo.cpp
new file mode 100644
index 0000000..1ad7267
--- /dev/null
+++ b/src/monte_carlo/test_monte_carlo.cpp
@@ -0,0 +1,58 @@
+#include "monte_carlo.hpp"
+#include "test_monte_carlo.hpp"
+#include <iostream>
+#include <map>
+
+using namespace std;
+using namespace game;
+
+namespace monte_carlo
+{
+ test_monte_carlo::test_monte_carlo()
+ {
+ play();
+ }
+
+ template <typename Game>
+ void test_monte_carlo::select_move(Game& game)
+ {
+ cout << game.player_to_string(game.current_player()) << " move: ";
+ map<string, int> m;
+ for (int i = 0; i < game.number_of_moves(); ++i)
+ {
+ m[game.move_to_string(i)] = i;
+ }
+ string move;
+ cin >> move;
+ game.play(m[move]);
+ }
+
+ void test_monte_carlo::play()
+ {
+ connect4 c4;
+ auto mc = make_monte_carlo(c4, 80000, 2000);
+ cout << "play one game" << endl;
+ cout << "who's first? (h)uman/(c)omputer ";
+ string ans;
+ cin >> ans;
+ cout << c4 << endl;
+ while (!c4.end_of_game())
+ {
+ if ((ans == "h" && c4.current_player() == 0) || (ans == "c" && c4.current_player() == 1))
+ {
+ select_move(c4);
+ }
+ else
+ {
+ uint16_t move = mc.select_move();
+ cout << c4.player_to_string(c4.current_player()) << " move: " << c4.move_to_string(move) << endl;
+ c4.play(move);
+ }
+ cout << c4 << endl;
+ }
+ if (c4.value(0) == 1) cout << c4.player_to_string(0) << " won";
+ else if (c4.value(1) == 1) cout << c4.player_to_string(1) << " won";
+ else cout << "draw";
+ cout << endl;
+ }
+}
diff --git a/src/monte_carlo/test_monte_carlo.hpp b/src/monte_carlo/test_monte_carlo.hpp
new file mode 100644
index 0000000..e1fceb2
--- /dev/null
+++ b/src/monte_carlo/test_monte_carlo.hpp
@@ -0,0 +1,18 @@
+#ifndef __TEST_MONTE_CARLO_HPP__
+#define __TEST_MONTE_CARLO_HPP__
+
+#include "connect4.hpp"
+
+namespace monte_carlo
+{
+ class test_monte_carlo
+ {
+ void play();
+ template <typename Game>
+ void select_move(Game& game);
+ public:
+ test_monte_carlo();
+ };
+}
+
+#endif
diff --git a/src/util/bits.cpp b/src/util/bits.cpp
new file mode 100644
index 0000000..bad4a45
--- /dev/null
+++ b/src/util/bits.cpp
@@ -0,0 +1,16 @@
+#include "bits.hpp"
+
+namespace util
+{
+ uint8_t bits::index64[64] =
+ {
+ 0, 47, 1, 56, 48, 27, 2, 60,
+ 57, 49, 41, 37, 28, 16, 3, 61,
+ 54, 58, 35, 52, 50, 42, 21, 44,
+ 38, 32, 29, 23, 17, 11, 4, 62,
+ 46, 55, 26, 59, 40, 36, 15, 53,
+ 34, 51, 20, 43, 31, 22, 10, 45,
+ 25, 39, 14, 33, 19, 30, 9, 24,
+ 13, 18, 8, 12, 7, 6, 5, 63
+ };
+}
diff --git a/src/util/bits.hpp b/src/util/bits.hpp
new file mode 100644
index 0000000..4aed894
--- /dev/null
+++ b/src/util/bits.hpp
@@ -0,0 +1,27 @@
+#ifndef __BITS_HPP__
+#define __BITS_HPP__
+
+#include <cstdint>
+
+namespace util
+{
+ class bits
+ {
+ static uint8_t index64[64];
+
+ public:
+ /**
+ * bit_scan_forward
+ * @author Kim Walisch (2012)
+ * @param bb bitboard to scan
+ * @precondition bb != 0
+ * @return index (0..63) of least significant one bit
+ */
+ static inline int bit_scan_forward(uint64_t bb)
+ {
+ const uint64_t debruijn64 = uint64_t(0x03f79d71b4cb0a89);
+ return index64[((bb ^ (bb-1)) * debruijn64) >> 58];
+ }
+ };
+}
+#endif
diff --git a/src/util/bits.hpp.gch b/src/util/bits.hpp.gch
new file mode 100644
index 0000000000000000000000000000000000000000..dddb27cdd57ad8a4ede839476dc90e518d6747ff
GIT binary patch
literal 2016048
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
F{{vJ?b{7Bu
literal 0
HcmV?d00001
diff --git a/src/util/display_node.cpp b/src/util/display_node.cpp
new file mode 100644
index 0000000..71cfd06
--- /dev/null
+++ b/src/util/display_node.cpp
@@ -0,0 +1,82 @@
+#include "display_node.hpp"
+#include <string>
+#include <iomanip>
+#include <sstream>
+
+using namespace std;
+
+namespace util
+{
+ void display_node::node_to_ascii(std::ostream& os, const mcts::node* n, unsigned int depth, unsigned int prunning)
+ {
+ node_to_ascii(os, "", n, depth, prunning);
+ os << endl;
+ }
+
+ void display_node::node_to_dot(std::ostream& os, const mcts::node* n, unsigned int depth, unsigned int prunning)
+ {
+ os << "digraph {" << endl;
+ node_to_dot(os, 0, n, depth, prunning);
+ os << "}" << endl;
+ }
+
+ int display_node::node_to_dot(ostream& os, int id, const mcts::node* n, unsigned int depth, unsigned int prunning)
+ {
+ stringbuf buffer;
+ ostream o (&buffer);
+ if (n->is_won())
+ o << "\"won\"";
+ else if (n->is_lost())
+ o << "\"lost\"";
+ else
+ o << "\"" << n->get_statistics().count << "\\n" << setprecision(2) << n->get_statistics().value << "\"";
+ string label = buffer.str();
+ os << id << "[label=" << label << "]" << endl;
+ if (depth == 0 || n->get_statistics().count < prunning || n->get_number_of_children() == 0) return id + 1;
+ int cpt = id + 1;
+ for (int i = 0; i < n->get_number_of_children(); ++i)
+ {
+ os << id << "->" << cpt << endl;
+ cpt = node_to_dot(os, cpt, n->get_children() + i, depth - 1, prunning);
+ }
+ return cpt + 1;
+ }
+
+ void display_node::node_to_ascii(ostream& os, string prefix, const mcts::node* n, unsigned int depth, unsigned int prunning)
+ {
+ string s;
+ s = n->get_statistics().to_string();
+ if (n->is_won()) s += "won";
+ else if (n->is_lost()) s += "lost";
+ // else s = n->get_statistics().to_string();
+ os << s;
+ unsigned int w = s.size();
+ string new_prefix = prefix + string(w + 1, ' ');
+ if (depth == 0 || n->get_statistics().count < prunning || n->get_number_of_children() == 0) return;
+ if (n->get_number_of_children() == 1)
+ {
+ os << "---";
+ node_to_ascii(os, new_prefix + " ", n->get_children(), depth - 1, prunning);
+ return;
+ }
+ os << "-";
+ children_to_ascii(os, new_prefix, n->get_number_of_children(), n->get_children(), depth, prunning);
+ }
+
+ void display_node::children_to_ascii(ostream& os, string prefix, unsigned int nb_children, const mcts::node* children, unsigned int depth, unsigned int prunning)
+ {
+ os << "+-";
+ node_to_ascii(os, prefix + "| ", children, depth - 1, prunning);
+ os << endl;
+ os << prefix;
+ for (unsigned int i = 1; i < nb_children - 1; ++i)
+ {
+ os << "|-";
+ node_to_ascii(os, prefix + "| ", children + i, depth - 1, prunning);
+ os << endl;
+ os << prefix;
+ }
+ os << "`-";
+ node_to_ascii(os, prefix + " ", children + nb_children - 1, depth - 1, prunning);
+ }
+}
diff --git a/src/util/display_node.hpp b/src/util/display_node.hpp
new file mode 100644
index 0000000..86837fe
--- /dev/null
+++ b/src/util/display_node.hpp
@@ -0,0 +1,22 @@
+#ifndef __DISPLAY_NODE_HPP__
+#define __DISPLAY_NODE_HPP__
+
+#include "node.hpp"
+#include <iostream>
+#include <limits>
+
+namespace util
+{
+ class display_node
+ {
+ public:
+ static void node_to_ascii(std::ostream& os, const mcts::node* n, unsigned int depth = std::numeric_limits<unsigned int>::max(), unsigned int prunning = 0);
+ static void node_to_dot(std::ostream& os, const mcts::node* n, unsigned int depth = std::numeric_limits<int>::max(), unsigned int prunning = 0);
+ private:
+ static void node_to_ascii(std::ostream& os, std::string prefix, const mcts::node* n, unsigned int depth, unsigned int prunning);
+ static void children_to_ascii(std::ostream& os, std::string prefix, unsigned int nb_children, const mcts::node* children, unsigned int depth, unsigned int prunning);
+ static int node_to_dot(std::ostream& os, int id, const mcts::node* n, unsigned int depth, unsigned int prunning);
+ };
+}
+
+#endif
diff --git a/src/util/fast_log.cpp b/src/util/fast_log.cpp
new file mode 100644
index 0000000..70ec031
--- /dev/null
+++ b/src/util/fast_log.cpp
@@ -0,0 +1,29 @@
+#include "fast_log.hpp"
+#include <cassert>
+#include <limits>
+
+namespace util
+{
+ fast_log::fast_log(int mantissa_nb_bits)
+ : mantissa_shift(MAX_MANTISSA_NB_BITS - mantissa_nb_bits)
+ {
+ assert(sizeof(int) == 4);
+ assert(std::numeric_limits<float>::is_iec559);
+ lookup_table = new float[1 << mantissa_nb_bits];
+ int_float x;
+ x._int = 0x3F800000;
+ int incr = (1 << mantissa_shift);
+ int p = (1 << mantissa_nb_bits);
+ float inv_log_two = 1.0f / log(2.0f);
+ for (int i = 0; i < p; ++i)
+ {
+ lookup_table[i] = log(x._float) * inv_log_two;
+ x._int += incr;
+ }
+ }
+
+ fast_log::~fast_log()
+ {
+ delete[] lookup_table;
+ }
+}
diff --git a/src/util/fast_log.hpp b/src/util/fast_log.hpp
new file mode 100644
index 0000000..482512d
--- /dev/null
+++ b/src/util/fast_log.hpp
@@ -0,0 +1,34 @@
+#ifndef __FAST_LOG_HPP__
+#define __FAST_LOG_HPP__
+
+namespace util
+{
+ class fast_log
+ {
+ public:
+ fast_log(int mantissa_nb_bits = 11);
+ ~fast_log();
+ inline float log(float v) const;
+ private:
+ union int_float
+ {
+ int _int;
+ float _float;
+ };
+ float* lookup_table;
+ const int mantissa_shift;
+ const int MAX_MANTISSA_NB_BITS = 23;
+ };
+
+ float fast_log::log(float val) const
+ {
+ int_float x;
+ x._float = val;
+ int exponent = ((x._int >> MAX_MANTISSA_NB_BITS) & 255) - 127;
+ x._int &= 0x7FFFFF;
+ x._int >>= mantissa_shift;
+ return (lookup_table[x._int] + float(exponent)) * 0.69314718f;
+ }
+}
+
+#endif
diff --git a/src/util/learning.hpp b/src/util/learning.hpp
new file mode 100644
index 0000000..da69bb8
--- /dev/null
+++ b/src/util/learning.hpp
@@ -0,0 +1,46 @@
+#ifndef __LEARNING_HPP__
+#define __LEARNING_HPP__
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <set>
+
+namespace util
+{
+ struct learning
+ {
+ template <typename Game>
+ static void display_file(Game& game, const std::string& filename);
+ };
+ template <typename Game>
+ void learning::display_file(Game& game, const std::string& filename)
+ {
+ using namespace std;
+ ifstream file(filename);
+ string line;
+ while (getline(file, line))
+ {
+ cout << line << endl;
+ double value;
+ set<int> input_vector;
+ int index, v;
+ char c;
+ stringstream ss(line);
+ ss >> value;
+ cout << "game value: " << value << endl;
+ while (ss >> index >> c >> v)
+ {
+ input_vector.insert(index);
+ }
+ game.from_input_vector(input_vector);
+ cout << "player to move: " << game.player_to_string(game.current_player()) << endl;
+ cout << game << endl;
+ getline(cin, line);
+ }
+ file.close();
+ }
+}
+
+#endif
diff --git a/src/util/omp_util.cpp b/src/util/omp_util.cpp
new file mode 100644
index 0000000..0f8493b
--- /dev/null
+++ b/src/util/omp_util.cpp
@@ -0,0 +1,23 @@
+#include "omp_util.hpp"
+
+namespace util
+{
+ int omp_util::get_num_threads()
+ {
+ int num_threads = 1;
+#if defined(_OPENMP)
+#pragma omp parallel
+ num_threads = omp_get_num_threads();
+#endif
+ return num_threads;
+ }
+
+ int omp_util::get_thread_num()
+ {
+ int thread_num = 0;
+#if defined(_OPENMP)
+ thread_num = omp_get_thread_num();
+#endif
+ return thread_num;
+ }
+}
diff --git a/src/util/omp_util.hpp b/src/util/omp_util.hpp
new file mode 100644
index 0000000..7f7d55f
--- /dev/null
+++ b/src/util/omp_util.hpp
@@ -0,0 +1,15 @@
+#ifndef __OMP_UTIL_HPP__
+#define __OMP_UTIL_HPP__
+
+#include <omp.h>
+
+namespace util
+{
+ struct omp_util
+ {
+ static int get_num_threads();
+ static int get_thread_num();
+ };
+}
+
+#endif
diff --git a/src/util/pow.hpp b/src/util/pow.hpp
new file mode 100644
index 0000000..a166551
--- /dev/null
+++ b/src/util/pow.hpp
@@ -0,0 +1,25 @@
+#ifndef __POW_HPP_
+#define __POW_HPP_
+
+namespace util
+{
+ long pow_l(long x, long n)
+ {
+ long res = 1;
+ while (n != 0)
+ {
+ if (n & 1)
+ {
+ n--;
+ res = res * x;
+ }
+ else
+ {
+ n = n / 2;
+ x = x * x;
+ }
+ }
+ return res;
+ }
+}
+#endif
diff --git a/src/util/test_bits.cpp b/src/util/test_bits.cpp
new file mode 100644
index 0000000..25be741
--- /dev/null
+++ b/src/util/test_bits.cpp
@@ -0,0 +1,37 @@
+#include "test_bits.hpp"
+#include <string.h>
+#include <chrono>
+#include <iostream>
+#include <random>
+
+using namespace std;
+
+namespace util
+{
+ test_bits::test_bits(unsigned int nb_samples)
+ {
+ volatile int res = 0;
+ default_random_engine generator(11);
+ uniform_int_distribution<uint64_t> distribution(0, uint64_t(0xFFFFFFFFFFFFFFFF));
+
+ chrono::steady_clock::time_point start = chrono::steady_clock::now();
+ for (unsigned int i = 1; i <= nb_samples; ++i)
+ {
+ uint64_t v = distribution(generator);
+ res += bits::bit_scan_forward(v);
+ }
+ cout << "res for debrujin: " << res << endl;
+ cout << "time for debrujin (ms): " << chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - start).count() << endl;
+
+ generator = default_random_engine(11);
+ res = 0;
+ start = chrono::steady_clock::now();
+ for (unsigned int i = 1; i <= nb_samples; ++i)
+ {
+ uint64_t v = distribution(generator);
+ res += ffsll(v) - 1;
+ }
+ cout << "res for ffsll: " << res << endl;
+ cout << "time for ffsll (ms): " << chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - start).count() << endl;
+ }
+}
diff --git a/src/util/test_bits.hpp b/src/util/test_bits.hpp
new file mode 100644
index 0000000..48daee4
--- /dev/null
+++ b/src/util/test_bits.hpp
@@ -0,0 +1,14 @@
+#ifndef __TEST_BITS_HPP__
+#define __TEST_BITS_HPP__
+
+#include "bits.hpp"
+
+namespace util
+{
+ struct test_bits
+ {
+ test_bits(unsigned int nb_samples);
+ };
+}
+
+#endif
diff --git a/src/util/test_fast_log.cpp b/src/util/test_fast_log.cpp
new file mode 100644
index 0000000..ba7a0c4
--- /dev/null
+++ b/src/util/test_fast_log.cpp
@@ -0,0 +1,50 @@
+#include "test_fast_log.hpp"
+#include <cmath>
+#include <chrono>
+#include <iostream>
+#include <random>
+
+using namespace std;
+
+namespace util
+{
+ test_fast_log::test_fast_log(unsigned int nb_samples, unsigned int mantissa_nb_bits)
+ : nb_samples(nb_samples), flog(mantissa_nb_bits)
+ {
+ precision();
+ time();
+ }
+
+ void test_fast_log::precision()
+ {
+ default_random_engine generator;
+ uniform_real_distribution<float> distribution(0.01,1000000.0);
+ double res = 0;
+ for (unsigned int i = 0; i < nb_samples; ++i)
+ {
+ float v = distribution(generator);
+ res += abs(log(v) - flog.log(v)) / (double)v;
+ }
+ cout << "precision: " << res / nb_samples << endl;
+ }
+
+ void test_fast_log::time()
+ {
+ volatile double res = 0;
+ chrono::steady_clock::time_point start = chrono::steady_clock::now();
+ for (unsigned int i = 1; i <= nb_samples; ++i)
+ {
+ res += log(i);
+ }
+ cout << "time for log (ms): " << chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - start).count() << endl;
+
+ res = 0;
+ start = chrono::steady_clock::now();
+ for (unsigned int i = 1; i <= nb_samples; ++i)
+ {
+ res += flog.log(i);
+ }
+ cout << "time for fast log (ms): " << chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - start).count() << endl;
+
+ }
+}
diff --git a/src/util/test_fast_log.hpp b/src/util/test_fast_log.hpp
new file mode 100644
index 0000000..bbfd2c7
--- /dev/null
+++ b/src/util/test_fast_log.hpp
@@ -0,0 +1,19 @@
+#ifndef __TEST_FAST_LOG_HPP__
+#define __TEST_FAST_LOG_HPP__
+
+#include "fast_log.hpp"
+
+namespace util
+{
+ class test_fast_log
+ {
+ unsigned int nb_samples;
+ fast_log flog;
+
+ void precision();
+ void time();
+ public:
+ test_fast_log(unsigned int nb_samples = 100000000U, unsigned int mantissa_nb_bits = 11);
+ };
+}
+#endif
--
GitLab