piecePairEval.tcc
Go to the documentation of this file.
00001 /* piecePairEval.tcc
00002  */
00003 #ifndef EVAL_PIECE_PAIR_EVAL_TCC
00004 #define EVAL_PIECE_PAIR_EVAL_TCC
00005 
00006 #include "osl/eval/ppair/piecePairEval.h"
00007 #include "osl/eval/ppair/piecePairAssert.h"
00008 #include "osl/container/pieceValues.h"
00009 #include "osl/pieceTable.h"
00010 #include "osl/oslConfig.h"
00011 
00012 template <class Table>
00013 osl::eval::ppair::
00014 PiecePairEvalTableBase<Table>::PiecePairEvalTableBase(const SimpleState& state) 
00015 {
00016   for (int i=0; i<Piece::SIZE; i++) {
00017     for (int j=i; j<Piece::SIZE; j++) {
00018       val += Table::Table.valueOf
00019         (PiecePairIndex::indexOfPieceNum(state, i), 
00020          PiecePairIndex::indexOfPieceNum(state, j));
00021     }
00022   }
00023 }
00024 
00025 template <class Table>
00026 bool& osl::eval::ppair::
00027 PiecePairEvalTableBase<Table>::initializationFlag()
00028 {
00029   static bool flag = false;
00030   return flag;
00031 }
00032 
00033 template <class Table>
00034 bool osl::eval::ppair::
00035 PiecePairEvalTableBase<Table>::setUp(const char *filename)
00036 {
00037   bool& result = initializationFlag();
00038   result = Table::Table.setUp(filename);
00039   return result;
00040 }
00041 
00042 template <class Table>
00043 bool osl::eval::ppair::
00044 PiecePairEvalTableBase<Table>::setUp()
00045 {
00046   std::string filename = OslConfig::home();
00047   filename += "/data/sibling-attack.pair";
00048   return setUp(filename.c_str());
00049 }
00050 
00051 template <class Table>
00052 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00053 adjustPairs(const SimpleState& state,
00054             unsigned int new_index)
00055 {
00056   int diff = 0;
00057   for (int i=0; i<Piece::SIZE; i++) 
00058   {
00059     const Piece p=state.pieceOf(i);
00060     if(p.isOnBoard()){
00061       const unsigned int target = 
00062         PiecePairIndex::indexOf(p);
00063       // 以下は target==old_index で1回以上(駒台)マッチ
00064       diff += Table::Table.valueOf(target, new_index);
00065     }
00066   }
00067   diff += Table::Table.valueOf(new_index, new_index);
00068   return diff;
00069 }
00070 
00071 template <class Table>
00072 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00073 adjustPairs(const SimpleState& state,
00074             unsigned int old_index, unsigned int new_index)
00075 {
00076   int diff = 0;
00077   for (int i=0; i<Piece::SIZE; i++) 
00078   {
00079     const Piece p=state.pieceOf(i);
00080     if(p.isOnBoard()){
00081       const unsigned int target = 
00082         PiecePairIndex::indexOf(p);
00083       diff -= Table::Table.valueOf(target, old_index);
00084       // 以下は target==old_index で1回以上(駒台)マッチ
00085       diff += Table::Table.valueOf(target, new_index);
00086     }
00087   }
00088   diff -= Table::Table.valueOf(old_index, new_index); // 足しすぎた分
00089   diff += Table::Table.valueOf(new_index, new_index);
00090   return diff;
00091 }
00092 
00093 template <class Table>
00094 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00095 adjustPairs(const SimpleState& state, 
00096             unsigned int old_index, unsigned int old_index2, 
00097             unsigned int new_index)
00098 {
00099   int diff = 0;
00100   for (int i=0;i<Piece::SIZE; i++) 
00101   {
00102     const Piece p=state.pieceOf(i);
00103     if(p.isOnBoard()){
00104       const unsigned int target = 
00105         PiecePairIndex::indexOf(p);
00106       diff += Table::Table.valueOf(target, new_index);
00107       diff -= Table::Table.valueOf(target, old_index);
00108       diff -= Table::Table.valueOf(target, old_index2);
00109     }
00110   }
00111 
00112   diff -= Table::Table.valueOf(old_index, new_index);
00113   diff -= Table::Table.valueOf(old_index2, new_index);
00114   diff += Table::Table.valueOf(old_index, old_index2);
00115 
00116   diff += Table::Table.valueOf(new_index, new_index);
00117   return diff;
00118 }
00119 
00120 // update
00121 template <class Table>
00122 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00123 adjustPairsAfterMove(const SimpleState& state,
00124                      unsigned int new_index)
00125 {
00126   int diff = 0;
00127   for (int i=0; i<Piece::SIZE; i++) 
00128   {
00129     const Piece p=state.pieceOf(i);
00130     if (p.isOnBoard()) {
00131       const unsigned int target = 
00132         PiecePairIndex::indexOf(p);
00133       diff += Table::Table.valueOf(target, new_index);
00134     }
00135   }
00136   return diff;
00137 }
00138 
00139 template <class Table>
00140 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00141 adjustPairsAfterMove(const SimpleState& state,
00142                      unsigned int old_index, unsigned int new_index)
00143 {
00144   int diff = 0;
00145   for (int i=0; i<Piece::SIZE; i++) 
00146   {
00147     const Piece p=state.pieceOf(i);
00148     if(p.isOnBoard()){
00149       const unsigned int target = 
00150         PiecePairIndex::indexOf(p);
00151       diff -= Table::Table.valueOf(target, old_index);
00152       diff += Table::Table.valueOf(target, new_index);
00153     }
00154   }
00155   diff -= Table::Table.valueOf(old_index, old_index);
00156   diff += Table::Table.valueOf(new_index, old_index); // 引きすぎた分
00157   return diff;
00158 }
00159 
00160 template <class Table>
00161 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00162 adjustPairsAfterMove(const SimpleState& state, 
00163                      unsigned int old_index, unsigned int old_index2, 
00164                      unsigned int new_index)
00165 {
00166   int diff = 0;
00167   for (int i=0;i<Piece::SIZE; i++) 
00168   {
00169     const Piece p=state.pieceOf(i);
00170     if(p.isOnBoard()){
00171       const unsigned int target = 
00172         PiecePairIndex::indexOf(p);
00173       diff += Table::Table.valueOf(target, new_index);
00174       diff -= Table::Table.valueOf(target, old_index);
00175       diff -= Table::Table.valueOf(target, old_index2);
00176     }
00177   }
00178 
00179   diff += Table::Table.valueOf(new_index, old_index);
00180   diff += Table::Table.valueOf(new_index, old_index2);
00181 
00182   diff -= Table::Table.valueOf(old_index, old_index2);
00183   diff -= Table::Table.valueOf(old_index, old_index);
00184   diff -= Table::Table.valueOf(old_index2, old_index2);
00185   return diff;
00186 }
00187 
00188 template <class Table>
00189 void osl::eval::ppair::PiecePairEvalTableBase<Table>::
00190 setValues(const SimpleState& state, container::PieceValues& values) 
00191 {
00192   values.fill(0);
00193   // 速度は無視
00194   for (int i=0; i<Piece::SIZE; i++) {
00195     const bool i_is_king = (Piece_Table.getPtypeOf(i) == KING);
00196     for (int j=0; j<Piece::SIZE; j++) {
00197       if (i==j)
00198         continue;
00199       const bool j_is_king = (Piece_Table.getPtypeOf(j) == KING);
00200       
00201       const int relation_value = Table::Table.valueOf
00202         (PiecePairIndex::indexOfPieceNum(state, i), 
00203          PiecePairIndex::indexOfPieceNum(state, j));
00204       if (i_is_king && (! j_is_king))
00205       {
00206         values[j] += relation_value;
00207       }
00208       else
00209       {
00210         values[i] += relation_value;
00211       }
00212     }
00213   }
00214   for (int i=0; i<Piece::SIZE; i++) 
00215   {
00216     values[i] /= 2;
00217 
00218     const unsigned int index = PiecePairIndex::indexOfPieceNum(state, i);
00219     const int self_value = Table::Table.valueOf(index, index);
00220     values[i] += self_value;
00221   }
00222 }
00223 
00224 /* ------------------------------------------------------------------------- */
00225 
00226 template <class Eval, class Table>
00227 osl::eval::ppair::
00228 PiecePairEval<Eval,Table>::PiecePairEval(const SimpleState& state) 
00229   : PiecePairEvalTableBase<Table>(state)
00230 {
00231 }
00232 
00233 template <class Eval, class Table>
00234 int osl::eval::ppair::PiecePairEval<Eval,Table>::
00235 expect(const SimpleState& state, Move m) const
00236 {
00237   const Ptype ptype = m.ptype();
00238   const Square to = m.to();
00239   const Player player = state.turn();
00240   if (m.isDrop()) {
00241     piece_pair_assert(state.pieceAt(to) == Piece::EMPTY());    
00242     return this->roundUp(this->val + Eval::diffAfterDropMove(state, to, newPtypeO(player, ptype)));
00243   }
00244   
00245   const Square from = m.from();
00246   piece_pair_assert(state.pieceAt(from) != Piece::EMPTY());
00247   if (m.capturePtype() == PTYPE_EMPTY) {
00248     piece_pair_assert(state.pieceAt(to) == Piece::EMPTY());
00249     return this->roundUp(this->val + Eval::diffAfterSimpleMove(state, from, to, m.promoteMask()));
00250   }
00251   piece_pair_assert(state.pieceAt(to) != Piece::EMPTY());
00252   return this->roundUp(this->val + Eval::diffAfterCaptureMove(state, from, to, m.capturePtypeO(), m.promoteMask()));
00253 }
00254 
00255 #endif /* EVAL_PIECE_PAIR_EVAL_TCC */
00256 // ;;; Local Variables:
00257 // ;;; mode:c++
00258 // ;;; c-basic-offset:2
00259 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines