/home/ug/devel/kombilo-py-dev/kombilo/libkombilo/algos.h

Go to the documentation of this file.

#ifndef _ALGOS_H_
#define _ALGOS_H_

#include <vector>
#include <stack>
#include <fstream>
#include "sqlite3.h"
#include "pstdint.h"
#include <boost/unordered_map.hpp>

#include "abstractboard.h"
#include "sgfparser.h"
#include "pattern.h"



class GameList;
class SearchOptions;


class Algorithm {
  public:
    Algorithm(int bsize);
    virtual ~Algorithm();

    virtual void initialize_process();                    
    virtual void newgame_process(int game_id);            
    virtual void AB_process(int x, int y);                
    virtual void AW_process(int x, int y);                
    virtual void AE_process(int x, int y, char removed);  
    virtual void endOfNode_process();                     
    virtual void move_process(Move m);                    
    virtual void pass_process();                          
    virtual void branchpoint_process();                   
    virtual void endOfVariation_process();                
    virtual void endgame_process(bool commit=true);       
    virtual void finalize_process();                      

    virtual SnapshotVector get_data();                    

    virtual int search(PatternList& patternList, GameList& gl, SearchOptions& options); 

    int gid;          
    int boardsize;    
};


// --------------------------------------------------------------------------------------------------

class Algo_signature : public Algorithm {
  public:
    Algo_signature(int bsize, SnapshotVector DATA);
    ~Algo_signature();
    void initialize_process();
    void newgame_process(int game_id);
    void AB_process(int x, int y);
    void AW_process(int x, int y);
    void AE_process(int x, int y, char removed);
    void endOfNode_process();
    void move_process(Move m);
    void pass_process();
    void branchpoint_process();
    void endOfVariation_process();
    void endgame_process(bool commit=true);
    void finalize_process();

    int counter;
    char* signature;
    char* get_current_signature();
    std::vector<int> search_signature(char* sig);

    SnapshotVector get_data();
    boost::unordered_multimap<string, int> data;
  private:
    bool main_variation;
};


class Algo_finalpos : public Algorithm {
  public:
    Algo_finalpos(int bsize, SnapshotVector DATA);
    ~Algo_finalpos();
    void initialize_process();
    void newgame_process(int game_id);
    void AB_process(int x, int y);
    void AW_process(int x, int y);
    void AE_process(int x, int y, char removed);
    void endOfNode_process();
    void move_process(Move m);
    void pass_process();
    void branchpoint_process();
    void endOfVariation_process();
    void endgame_process(bool commit=true);
    void finalize_process();
    hashtype get_current_fphash();
    hashtype get_fphash(int index);

    char* fp;
    int fpIndex;

    SnapshotVector get_data();
    std::vector<pair<int, char* > > data;

    int search(PatternList& patternList, GameList& gl, SearchOptions& options);
};


// -------------------------------------------------------------------------------------------------------


// in x-coord:
const int ENDOFNODE = 128;
const int BRANCHPOINT = 64;
const int ENDOFVARIATION = 32;

// in y-coord
const int REMOVE = 128;
const int BLACK = 64;
const int WHITE = 32;


class MovelistCand {
  public:
    int orientation;
    Pattern* p;
    char* dicts;
    ExtendedMoveNumber dictsF;
    bool dictsFound;
    ExtendedMoveNumber dictsFI;
    bool node_changes_relevant_region;
    bool dictsFoundInitial;
    bool dictsDR;
    int dictsNO;
    std::vector<MoveNC> contList;
    int contListIndex;
    p_cc Xinterv;
    p_cc Yinterv;
    char mx;
    char my;

    MovelistCand(Pattern* P, int ORIENTATION, char* DICTS, int NO, char X, char Y);
    ~MovelistCand();
    char dictsget(char x, char y);
    void dictsset(char x, char y, char d);
    bool in_relevant_region(char x, char y);
    char contlistgetX(int i);
    char contlistgetY(int i);
    char contlistgetCO(int i);
};

class VecMC : public std::vector<MovelistCand* > {
  public:
    VecMC();
    ~VecMC();
    VecMC* deepcopy(ExtendedMoveNumber& COUNTER, int CANDSSIZE);
    ExtendedMoveNumber counter;
    int candssize;
};




class Algo_movelist : public Algorithm {
  public:
    Algo_movelist(int bsize, SnapshotVector DATA);
    ~Algo_movelist();
    void initialize_process();
    void newgame_process(int game_id);
    void AB_process(int x, int y);
    void AW_process(int x, int y);
    void AE_process(int x, int y, char removed);
    void endOfNode_process();
    void move_process(Move m);
    void pass_process();
    void branchpoint_process();
    void endOfVariation_process();
    void endgame_process(bool commit=true);
    void finalize_process();
    int search(PatternList& patternList, GameList& gl, SearchOptions& options);

    std::vector<char> movelist;
    char* fpC;
    std::map<int, char* > data1;
    std::map<int, char* > data2;
    std::map<int, int> data1l;
    SnapshotVector get_data();
};


// --------------------------------------------------------------------------------------------------------



class HashhitF { // hashing hit for full board search
  public:
    int gameid;
    char orientation;
    MoveNC* cont;
    ExtendedMoveNumber* emn;

    HashhitF();
    HashhitF(int GAMEID, char ORIENTATION, ExtendedMoveNumber& EMN, MoveNC* CONT);
    HashhitF(int GAMEID, char ORIENTATION, char* blob);
    HashhitF(const HashhitF& HHF);
    ~HashhitF();
    HashhitF& operator=(const HashhitF& HHF);

    char* export_blob();
};

typedef vector<HashhitF* >* vpsip;

class HashhitCS { // hashing hit for corner/side pattern search
  public:
    int gameid;
    int position;
    bool cs;
    HashhitCS(int GAMEID, int POSITION, bool CS);
    bool operator==(const HashhitCS& hhc);
};

class HashVarInfo {
  public:
    hashtype chc;
    std::vector<std::pair<hashtype, ExtendedMoveNumber> > * lfc;
    ExtendedMoveNumber* moveNumber;
    int numStones;

    HashVarInfo(hashtype CHC, std::vector<std::pair<hashtype, ExtendedMoveNumber> > * LFC, ExtendedMoveNumber* MOVENUMBER, int NUMSTONES);
};

class Algo_hash_full : public Algorithm {
  public:
    Algo_hash_full(int bsize, SnapshotVector DATA, const string OS_DATA_NAME, int MAXNUMSTONES = 50);
    ~Algo_hash_full();
    void initialize_process();
    void newgame_process(int game_id);
    void AB_process(int x, int y);
    void AW_process(int x, int y);
    void AE_process(int x, int y, char removed);
    void endOfNode_process();
    void move_process(Move m);
    void pass_process();
    void branchpoint_process();
    void endOfVariation_process();
    void endgame_process(bool commit=true);
    void finalize_process();
    int search(PatternList& patternList, GameList& gl, SearchOptions& options);

    void process_lfc(int x, int y, char color);
    hashtype compute_hashkey(Pattern& pattern);
    int maxNumStones;
    int numStones;

    vector<pair<hashtype, int> > data;
    boost::unordered_multimap<hashtype, HashhitF> data_p;
    SnapshotVector get_data();
    fstream os_data;
    
  private:
    hashtype currentHashCode;
    ExtendedMoveNumber* moveNumber;
    std::vector<std::pair<hashtype, ExtendedMoveNumber> > *lfc; // hash code + move number, still *l*ooking *f*or *c*ontinuation
    std::stack<HashVarInfo>* branchpoints;
    boost::unordered_multimap<hashtype, HashhitF> hash_vector;
    void get_HHF(int ptr, vpsip results, int orientation);
};


// --------------------------------------------------------------------------------------------


class HashInstance {
  // When processing sgf games, Algo_hash maintains a list of HashInstance's -
  // those are regions on the board for which hash codes are put into the
  // database

  public:
    HashInstance(char X, char Y, char SIZEX, char SIZEY, int BOARDSIZE);
    ~HashInstance();
    bool inRelevantRegion(char X, char Y);

    char xx; // position on the board
    char yy;
    int pos;
    int boardsize;
    char sizeX; // size of the pattern
    char sizeY;
    bool changed;

    void initialize();
    void finalize();
    void addB(char x, char y);
    void removeB(char x, char y);
    void addW(char x, char y);
    void removeW(char x, char y);
    void bppush();
    void bppop();
    std::pair<hashtype,int> cHC();  // returns min(currentHashCode) and corresp. index
    hashtype* currentHashCode; // array of 8 hashtype values (to automatically symmetrize hash codes)
    std::stack<std::pair<hashtype*,int> >* branchpoints;
    int numStones;
};

class Algo_hash : public Algorithm {
  // This class should not be used by the "end-user" (see Algo_hash_corner and
  // Algo_hash_sides instead)

  public:
    Algo_hash(int bsize, SnapshotVector DATA, string OS_DATA_NAME, int MAXNUMSTONES);
    virtual ~Algo_hash();
    virtual void initialize_process();
    virtual void newgame_process(int game_id);
    virtual void AB_process(int x, int y);
    virtual void AW_process(int x, int y);
    virtual void AE_process(int x, int y, char removed);
    virtual void endOfNode_process();
    virtual void move_process(Move m);
    virtual void pass_process();
    virtual void branchpoint_process();
    virtual void endOfVariation_process();
    virtual void endgame_process(bool commit=true);
    virtual void finalize_process();

    virtual int search(PatternList& patternList, GameList& gl, SearchOptions& options);

    friend class GameList;
    friend class Algo_hash_full;
    friend class HashInstance;
    
  protected:

    int maxNumStones;
    SnapshotVector get_data(); //< Used to read data from disk into \c data
    
    virtual void get_HHCS(int ptr, vector<HashhitCS* >* results, bool cs);

    virtual std::pair<hashtype,std::vector<int> >  compute_hashkey(PatternList& pl, int CS);
    static const hashtype hashCodes[];
    std::vector<HashInstance>* hi;
    std::vector<std::pair<hashtype, int> > hash_vector;

    vector<pair<hashtype, int> > data;
    boost::unordered_multimap<hashtype, pair<int,int> > data_p;
    fstream os_data;
};

class Algo_hash_corner : public Algo_hash {
  public:
    Algo_hash_corner(int bsize, SnapshotVector DATA, string OS_DATA_NAME, int SIZE=7, int MAXNUMSTONES = 20);

    std::pair<hashtype,std::vector<int> >  compute_hashkey(PatternList& pl, int CS);

    int size;
};


// ---------------------------------------------------------------------------------------------------------------


typedef Algorithm* algo_p;


#endif