documentation/libmcts/mcts_8hpp_source.html

 #ifndef MCTS_H
 #define MCTS_H

 #include "root_node.hpp"

 namespace mcts {

 // ----------------------------------------------------------------------
 // ----------------------------------------------------------------------
 template <typename Context, typename Config, typename WrapNode,
           typename ResultType>
 class MCTS {
   typedef typename INode<Context, Config>::node_t node_t;
   typedef typename RootNode<Context, Config, WrapNode>::root_node_t root_node_t;

 public:
   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   MCTS(const Context &context, Config *config)
       : tree(new root_node_t(context, config)), iteration_cnt(0) {}

   virtual ~MCTS() { delete tree; }

   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   void iterate() {
     node_t *selected_leaf = tree->select_recusively();
     double value = selected_leaf->simulate();
     selected_leaf->backpropagate(value);
     ++iteration_cnt;
   }

   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   ResultType result() {
     return ResultType(tree->config()->move_selector()->select(tree));
   }

   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   const node_t *root() const { return tree; }

   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   unsigned nb_nodes() { return tree->count_recursive(); }

   // ----------------------------------------------------------------------
   // ----------------------------------------------------------------------
   unsigned nb_iterations() { return iteration_cnt; }

 private:
   node_t *tree;
   unsigned iteration_cnt;
 };
 }

 #endif
mcts::RootNode
special node that is the root of each tree. Its merely a wrapper that wrapps around a inner node.
Definition: root_node.hpp:18

mcts::MCTS::nb_iterations
unsigned nb_iterations()
gets the number of performed iterations. the counter is increased each time the function iterate() is...
Definition: mcts.hpp:84

mcts::MCTS
mainclass to interact with the library. it holds the root of the searchtree.
Definition: mcts.hpp:19

mcts::MCTS::MCTS
MCTS(const Context &context, Config *config)
creates a new empty mcts object. only a root node exists.
Definition: mcts.hpp:31

mcts::INode::backpropagate
virtual void backpropagate(const double &value)=0
applies a backpropagation strategy to traverse the simulated result back up in the tree.

mcts::INode
basic interface for a node in the tree. Every node has to implement this functions.
Definition: inode.hpp:18

mcts::MCTS::result
ResultType result()
gets the current result node. The node is selected according to a metric defined in a selection strat...
Definition: mcts.hpp:60

mcts::MCTS::iterate
void iterate()
executes one interation step. Each iteration consists of the following actions:
Definition: mcts.hpp:45

mcts::MCTS::root
const node_t * root() const
gets the root of the node.
Definition: mcts.hpp:69

mcts::INode::config
virtual Config * config() const =0
gets the config object

mcts::INode::simulate
virtual double simulate() const =0
applies a simulation strategy to a terminal node.

mcts::INode::select_recusively
virtual node_t * select_recusively()=0
recursively selects nodes with a given simulation strategy until an terminal node is reached.

mcts::INode::count_recursive
virtual unsigned count_recursive() const
recursively counts number of childen beneth this nodes. counts in the current node.
Definition: inode.hpp:139

mcts::MCTS::nb_nodes
unsigned nb_nodes()
gets the number of nodes the tree is currently holding.
Definition: mcts.hpp:76