3 #ifndef EVAL_PIECE_PAIR_EVAL_TCC 
    4 #define EVAL_PIECE_PAIR_EVAL_TCC 
   12 template <
class Table>
 
   16   for (
int i=0; i<Piece::SIZE; i++) {
 
   17     for (
int j=i; j<Piece::SIZE; j++) {
 
   18       val += Table::Table.valueOf
 
   19         (PiecePairIndex::indexOfPieceNum(state, i), 
 
   20          PiecePairIndex::indexOfPieceNum(state, j));
 
   25 template <
class Table>
 
   29   static bool flag = 
false;
 
   33 template <
class Table>
 
   37   bool& 
result = initializationFlag();
 
   38   result = Table::Table.setUp(filename);
 
   42 template <
class Table>
 
   46   std::string filename = OslConfig::home();
 
   47   filename += 
"/data/sibling-attack.pair";
 
   48   return setUp(filename.c_str());
 
   51 template <
class Table>
 
   54             unsigned int new_index)
 
   57   for (
int i=0; i<Piece::SIZE; i++) 
 
   59     const Piece p=state.pieceOf(i);
 
   61       const unsigned int target = 
 
   62         PiecePairIndex::indexOf(p);
 
   64       diff += Table::Table.valueOf(target, new_index);
 
   67   diff += Table::Table.valueOf(new_index, new_index);
 
   71 template <
class Table>
 
   74             unsigned int old_index, 
unsigned int new_index)
 
   77   for (
int i=0; i<Piece::SIZE; i++) 
 
   79     const Piece p=state.pieceOf(i);
 
   81       const unsigned int target = 
 
   82         PiecePairIndex::indexOf(p);
 
   83       diff -= Table::Table.valueOf(target, old_index);
 
   85       diff += Table::Table.valueOf(target, new_index);
 
   88   diff -= Table::Table.valueOf(old_index, new_index); 
 
   89   diff += Table::Table.valueOf(new_index, new_index);
 
   93 template <
class Table>
 
   96             unsigned int old_index, 
unsigned int old_index2, 
 
   97             unsigned int new_index)
 
  100   for (
int i=0;i<Piece::SIZE; i++) 
 
  102     const Piece p=state.pieceOf(i);
 
  104       const unsigned int target = 
 
  105         PiecePairIndex::indexOf(p);
 
  106       diff += Table::Table.valueOf(target, new_index);
 
  107       diff -= Table::Table.valueOf(target, old_index);
 
  108       diff -= Table::Table.valueOf(target, old_index2);
 
  112   diff -= Table::Table.valueOf(old_index, new_index);
 
  113   diff -= Table::Table.valueOf(old_index2, new_index);
 
  114   diff += Table::Table.valueOf(old_index, old_index2);
 
  116   diff += Table::Table.valueOf(new_index, new_index);
 
  121 template <
class Table>
 
  124                      unsigned int new_index)
 
  127   for (
int i=0; i<Piece::SIZE; i++) 
 
  129     const Piece p=state.pieceOf(i);
 
  131       const unsigned int target = 
 
  132         PiecePairIndex::indexOf(p);
 
  133       diff += Table::Table.valueOf(target, new_index);
 
  139 template <
class Table>
 
  142                      unsigned int old_index, 
unsigned int new_index)
 
  145   for (
int i=0; i<Piece::SIZE; i++) 
 
  147     const Piece p=state.pieceOf(i);
 
  149       const unsigned int target = 
 
  150         PiecePairIndex::indexOf(p);
 
  151       diff -= Table::Table.valueOf(target, old_index);
 
  152       diff += Table::Table.valueOf(target, new_index);
 
  155   diff -= Table::Table.valueOf(old_index, old_index);
 
  156   diff += Table::Table.valueOf(new_index, old_index); 
 
  160 template <
class Table>
 
  163                      unsigned int old_index, 
unsigned int old_index2, 
 
  164                      unsigned int new_index)
 
  167   for (
int i=0;i<Piece::SIZE; i++) 
 
  169     const Piece p=state.pieceOf(i);
 
  171       const unsigned int target = 
 
  172         PiecePairIndex::indexOf(p);
 
  173       diff += Table::Table.valueOf(target, new_index);
 
  174       diff -= Table::Table.valueOf(target, old_index);
 
  175       diff -= Table::Table.valueOf(target, old_index2);
 
  179   diff += Table::Table.valueOf(new_index, old_index);
 
  180   diff += Table::Table.valueOf(new_index, old_index2);
 
  182   diff -= Table::Table.valueOf(old_index, old_index2);
 
  183   diff -= Table::Table.valueOf(old_index, old_index);
 
  184   diff -= Table::Table.valueOf(old_index2, old_index2);
 
  188 template <
class Table>
 
  194   for (
int i=0; i<Piece::SIZE; i++) {
 
  196     for (
int j=0; j<Piece::SIZE; j++) {
 
  201       const int relation_value = Table::Table.valueOf
 
  202         (PiecePairIndex::indexOfPieceNum(state, i), 
 
  203          PiecePairIndex::indexOfPieceNum(state, j));
 
  204       if (i_is_king && (! j_is_king))
 
  206         values[j] += relation_value;
 
  210         values[i] += relation_value;
 
  214   for (
int i=0; i<Piece::SIZE; i++) 
 
  218     const unsigned int index = PiecePairIndex::indexOfPieceNum(state, i);
 
  219     const int self_value = Table::Table.valueOf(index, index);
 
  220     values[i] += self_value;
 
  226 template <
class Eval, 
class Table>
 
  233 template <
class Eval, 
class Table>
 
  239   const Player player = state.turn();
 
  242     return this->roundUp(this->val + Eval::diffAfterDropMove(state, to, 
newPtypeO(player, ptype)));
 
  249     return this->roundUp(this->val + Eval::diffAfterSimpleMove(state, from, to, m.
promoteMask()));