openMidEndingEval.cc
Go to the documentation of this file.
00001 #include "osl/eval/ml/openMidEndingEval.h"
00002 #include "osl/eval/ml/piecePair.h"
00003 #include "osl/eval/ml/piecePairKing.h"
00004 #include "osl/eval/ml/kingTable.h"
00005 #include "osl/eval/ml/majorPiece.h"
00006 #include "osl/eval/ml/minorPiece.h"
00007 #include "osl/eval/ml/mobility.h"
00008 #include "osl/eval/ml/pieceStand.h"
00009 #include "osl/eval/ml/pin.h"
00010 #include "osl/eval/ml/king8.h"
00011 #include "osl/eval/ml/progress.h"
00012 #include "osl/effect_util/pin.h"
00013 #include "osl/misc/random.h"
00014 #include "osl/misc/binaryIO.h"
00015 #include "osl/oslConfig.h"
00016 #include "osl/pieceStand.h"
00017 
00018 #include <boost/foreach.hpp>
00019 #include <boost/thread/mutex.hpp>
00020 #include <fstream>
00021 
00022 osl::eval::ml::OpenMidEndingPtypeTable::
00023 OpenMidEndingPtypeTable()
00024 {
00025   const CArray<int, PTYPE_SIZE> values = {{
00026       0, 0,
00027       583, 493, 491, 467, 1279, 1351,
00028       PtypeEvalTraits<KING>::val, 585,
00029       128, 318, 361, 540, 959, 1059
00030     }};
00031   reset(values);
00032 }
00033 
00034 volatile osl::eval::ml::OpenMidEndingEval::LoadStatus
00035 osl::eval::ml::OpenMidEndingEval::initialized_flag = osl::eval::ml::OpenMidEndingEval::Zero;
00036 static boost::mutex initialize_mutex;
00037 osl::eval::ml::Weights
00038 osl::eval::ml::OpenMidEndingEval::piece_pair_weights;
00039 namespace
00040 {
00041 #ifndef MINIMAL
00042   template <class Eval>
00043   static void setRandomOne()
00044   {
00045     osl::eval::ml::Weights weights(Eval::DIM);
00046     for (size_t i = 0; i < weights.dimension(); ++i)
00047     {
00048       weights.setValue(i, (osl::misc::random() % 1024)-512);
00049     }
00050     Eval::setUp(weights);
00051   }
00052   template <class Eval>
00053   static void setRandomOne(int stage)
00054   {
00055     osl::eval::ml::Weights weights(Eval::DIM);
00056     for (size_t i = 0; i < weights.dimension(); ++i)
00057     {
00058       weights.setValue(i, (osl::misc::random() % 1024)-512);
00059     }
00060     Eval::setUp(weights, stage);
00061   }
00062 #endif
00063   typedef osl::misc::BinaryElementReader<int> reader_t;
00064   template <class Eval>
00065   static int setUpOne(reader_t& p)
00066   {
00067     osl::eval::ml::Weights weights(Eval::DIM);
00068     // std::cerr << typeid(Eval).name() << " " << Eval::DIM << "\n";
00069     for (size_t i = 0; i < weights.dimension(); ++i)
00070     {
00071       if (! p.hasNext())
00072         break;
00073       int val = p.read();
00074       weights.setValue(i, val);
00075     }
00076     Eval::setUp(weights);
00077     return weights.dimension();
00078   }
00079   template <class Eval>
00080   static int setUpOne(reader_t& p, int stage)
00081   {
00082     osl::eval::ml::Weights weights(Eval::DIM);
00083     // std::cerr << typeid(Eval).name() << " " << Eval::DIM << "\n";
00084     for (size_t i = 0; i < weights.dimension(); ++i)
00085     {
00086       if (!p.hasNext())
00087         break;
00088       int val = p.read();
00089       weights.setValue(i, val);
00090     }
00091     Eval::setUp(weights,stage);
00092     return weights.dimension();
00093   }
00094 }
00095 
00096 bool osl::eval::ml::OpenMidEndingEval::setUp(const char *filename)
00097 {
00098   if (initialized_flag == Loaded)
00099     return true;
00100   boost::mutex::scoped_lock lk(initialize_mutex);
00101   std::ifstream is(filename);
00102   reader_t reader(is);
00103   if (! reader.hasNext()) {
00104     initialized_flag = Zero;
00105     return false;
00106   }
00107   Weights weights(PTYPE_SIZE);
00108   size_t read_count = 0;
00109 
00110   // flat
00111   for (int i = 0; i < PTYPE_SIZE; ++i)
00112   {
00113     if (! reader.hasNext())
00114       break;
00115     int val = reader.read();
00116     weights.setValue(i, val);
00117     ++read_count;
00118   }
00119   PieceEval::setUp(weights);
00120 
00121   PiecePair::init();
00122   piece_pair_weights.resetDimension(PiecePair::DIM);
00123   for (size_t i = 0; i < piece_pair_weights.dimension(); ++i)
00124   {
00125     if (! reader.hasNext())
00126       break;
00127     int val = reader.read();
00128     piece_pair_weights.setValue(i, val);
00129     ++read_count;
00130   }
00131   PiecePair::sanitize(piece_pair_weights);
00132   PiecePair::compile(piece_pair_weights);
00133 
00134   read_count += setUpOne<King25EffectAttack>(reader);
00135   read_count += setUpOne<King25EffectYAttack>(reader);
00136   read_count += setUpOne<PiecePairKing>(reader);
00137   read_count += setUpOne<BishopExchangeSilverKing>(reader);
00138   read_count += setUpOne<EnterKingDefense>(reader);
00139 
00140   // opening
00141   read_count += setUpOne<PieceStand>(reader,0);
00142   read_count += setUpOne<King25EffectEachBothOpening>(reader);
00143   read_count += setUpOne<PawnDrop>(reader,0);
00144   read_count += setUpOne<NoPawnOnStand>(reader,0);
00145   read_count += setUpOne<GoldRetreat>(reader,0);
00146   read_count += setUpOne<SilverRetreat>(reader,0);
00147   read_count += setUpOne<KnightAdvance>(reader,0);
00148   read_count += setUpOne<AllMajor>(reader,0);
00149   read_count += setUpOne<KingXBlocked>(reader,0);
00150   read_count += setUpOne<KingXBlockedY>(reader,0);
00151   read_count += setUpOne<AllGold>(reader,0);
00152   read_count += setUpOne<PtypeX>(reader,0);
00153   read_count += setUpOne<PtypeY>(reader,0);
00154   read_count += setUpOne<AnagumaEmpty>(reader,0);
00155   read_count += setUpOne<NonPawnPieceStand>(reader,0);
00156   read_count += setUpOne<King25EffectDefense>(reader,0);
00157   read_count += setUpOne<King25EffectYDefense>(reader,0);
00158   read_count += setUpOne<RookMobility>(reader,0);
00159   read_count += setUpOne<BishopMobility>(reader,0);
00160   read_count += setUpOne<LanceMobility>(reader,0);
00161   read_count += setUpOne<RookEffect>(reader,0);
00162   read_count += setUpOne<BishopEffect>(reader,0);
00163   read_count += setUpOne<PawnAdvance>(reader,0);
00164   read_count += setUpOne<PawnDropY>(reader,0);
00165   read_count += setUpOne<KnightCheck>(reader,0);
00166 
00167   // midgame
00168   read_count += setUpOne<PieceStand>(reader,1);
00169   read_count += setUpOne<King25EffectEachBothMidgame>(reader);
00170   read_count += setUpOne<PawnDrop>(reader,1);
00171   read_count += setUpOne<NoPawnOnStand>(reader,1);
00172   read_count += setUpOne<GoldRetreat>(reader,1);
00173   read_count += setUpOne<SilverRetreat>(reader,1);
00174   read_count += setUpOne<KnightAdvance>(reader,1);
00175   read_count += setUpOne<AllMajor>(reader,1);
00176   read_count += setUpOne<KingXBlocked>(reader,1);
00177   read_count += setUpOne<KingXBlockedY>(reader,1);
00178   read_count += setUpOne<AllGold>(reader,1);
00179   read_count += setUpOne<PtypeX>(reader,1);
00180   read_count += setUpOne<PtypeY>(reader,1);
00181   read_count += setUpOne<AnagumaEmpty>(reader,1);
00182   read_count += setUpOne<NonPawnPieceStand>(reader,1);
00183   read_count += setUpOne<King25EffectDefense>(reader,1);
00184   read_count += setUpOne<King25EffectYDefense>(reader,1);
00185   read_count += setUpOne<RookMobility>(reader,1);
00186   read_count += setUpOne<BishopMobility>(reader,1);
00187   read_count += setUpOne<LanceMobility>(reader,1);
00188   read_count += setUpOne<RookEffect>(reader,1);
00189   read_count += setUpOne<BishopEffect>(reader,1);
00190   read_count += setUpOne<PawnAdvance>(reader,1);
00191   read_count += setUpOne<PawnDropY>(reader,1);
00192   read_count += setUpOne<KnightCheck>(reader,1);
00193 
00194 #ifdef EVAL_QUAD
00195   // midgame2
00196   read_count += setUpOne<PieceStand>(reader,2);
00197   read_count += setUpOne<King25EffectEachBothMidgame2>(reader);
00198   read_count += setUpOne<PawnDrop>(reader,2);
00199   read_count += setUpOne<NoPawnOnStand>(reader,2);
00200   read_count += setUpOne<GoldRetreat>(reader,2);
00201   read_count += setUpOne<SilverRetreat>(reader,2);
00202   read_count += setUpOne<KnightAdvance>(reader,2);
00203   read_count += setUpOne<AllMajor>(reader,2);
00204   read_count += setUpOne<KingXBlocked>(reader,2);
00205   read_count += setUpOne<KingXBlockedY>(reader,2);
00206   read_count += setUpOne<AllGold>(reader,2);
00207   read_count += setUpOne<PtypeX>(reader,2);
00208   read_count += setUpOne<PtypeY>(reader,2);
00209   read_count += setUpOne<AnagumaEmpty>(reader,2);
00210   read_count += setUpOne<NonPawnPieceStand>(reader,2);
00211   read_count += setUpOne<King25EffectDefense>(reader,2);
00212   read_count += setUpOne<King25EffectYDefense>(reader,2);
00213   read_count += setUpOne<RookMobility>(reader,2);
00214   read_count += setUpOne<BishopMobility>(reader,2);
00215   read_count += setUpOne<LanceMobility>(reader,2);
00216   read_count += setUpOne<RookEffect>(reader,2);
00217   read_count += setUpOne<BishopEffect>(reader,2);
00218   read_count += setUpOne<PawnAdvance>(reader,2);
00219   read_count += setUpOne<PawnDropY>(reader,2);
00220   read_count += setUpOne<KnightCheck>(reader,2);
00221 #endif
00222 
00223   // endgame
00224   read_count += setUpOne<PieceStand>(reader,EndgameIndex);
00225   read_count += setUpOne<King25EffectEachBothEnding>(reader);
00226   read_count += setUpOne<PawnDrop>(reader,EndgameIndex);
00227   read_count += setUpOne<NoPawnOnStand>(reader,EndgameIndex);
00228   read_count += setUpOne<GoldRetreat>(reader,EndgameIndex);
00229   read_count += setUpOne<SilverRetreat>(reader,EndgameIndex);
00230   read_count += setUpOne<KnightAdvance>(reader,EndgameIndex);
00231   read_count += setUpOne<AllMajor>(reader,EndgameIndex);
00232   read_count += setUpOne<KingXBlocked>(reader,EndgameIndex);
00233   read_count += setUpOne<KingXBlockedY>(reader,EndgameIndex);
00234   read_count += setUpOne<AllGold>(reader,EndgameIndex);
00235   read_count += setUpOne<PtypeX>(reader,EndgameIndex);
00236   read_count += setUpOne<PtypeY>(reader,EndgameIndex);
00237   read_count += setUpOne<AnagumaEmpty>(reader,EndgameIndex);
00238   read_count += setUpOne<NonPawnPieceStand>(reader,EndgameIndex);
00239   read_count += setUpOne<King25EffectDefense>(reader,EndgameIndex);
00240   read_count += setUpOne<King25EffectYDefense>(reader,EndgameIndex);
00241   read_count += setUpOne<RookMobility>(reader,EndgameIndex);
00242   read_count += setUpOne<BishopMobility>(reader,EndgameIndex);
00243   read_count += setUpOne<LanceMobility>(reader,EndgameIndex);
00244   read_count += setUpOne<RookEffect>(reader,EndgameIndex);
00245   read_count += setUpOne<BishopEffect>(reader,EndgameIndex);
00246   read_count += setUpOne<PawnAdvance>(reader,EndgameIndex);
00247   read_count += setUpOne<PawnDropY>(reader,EndgameIndex);
00248   read_count += setUpOne<KnightCheck>(reader,EndgameIndex);
00249 
00250   // triple
00251   read_count += setUpOne<KingPieceRelative>(reader,0);
00252   read_count += setUpOne<KingPieceRelative>(reader,1);
00253 #ifdef EVAL_QUAD
00254   read_count += setUpOne<KingPieceRelative>(reader,2);
00255 #endif
00256   read_count += setUpOne<KingPieceRelative>(reader,EndgameIndex);
00257   read_count += setUpOne<NonPawnPieceStandTurn>(reader);
00258   read_count += setUpOne<King25EffectEachXY>(reader);
00259   read_count += setUpOne<RookPawnY>(reader);
00260   read_count += setUpOne<RookEffectPiece>(reader);
00261   read_count += setUpOne<BishopEffectPiece>(reader);
00262   read_count += setUpOne<PieceStandY>(reader);
00263   read_count += setUpOne<RookEffectPieceKingRelative>(reader);
00264   read_count += setUpOne<BishopEffectPieceKingRelative>(reader);
00265   read_count += setUpOne<RookPawnYX>(reader);
00266   read_count += setUpOne<PawnPtypeOPtypeO>(reader);
00267   read_count += setUpOne<PromotedMinorPieces>(reader);
00268   read_count += setUpOne<KingPieceRelativeNoSupport>(reader);
00269   read_count += setUpOne<NonPawnAttacked>(reader);
00270   read_count += setUpOne<PtypeYY>(reader);
00271   read_count += setUpOne<PawnPtypeOPtypeOY>(reader);
00272   read_count += setUpOne<PawnDropX>(reader);
00273   read_count += setUpOne<King3Pieces>(reader);
00274   read_count += setUpOne<King3PiecesXY>(reader);
00275   read_count += setUpOne<King25EffectEachKXY>(reader);
00276   read_count += setUpOne<BishopHead>(reader);
00277   read_count += setUpOne<BishopHeadKingRelative>(reader);
00278   read_count += setUpOne<KnightCheckY>(reader);
00279   read_count += setUpOne<KnightHead>(reader);
00280   read_count += setUpOne<RookPromoteDefense>(reader);
00281   read_count += setUpOne<PawnDropPawnStand>(reader);
00282   read_count += setUpOne<PawnDropPawnStandX>(reader);
00283   read_count += setUpOne<PawnDropPawnStandY>(reader);
00284   read_count += setUpOne<KnightHeadOppPiecePawnOnStand>(reader);
00285   read_count += setUpOne<KingXBothBlocked>(reader);
00286   read_count += setUpOne<KingXBothBlockedY>(reader);
00287   read_count += setUpOne<KingRookBishop>(reader);
00288   read_count += setUpOne<PromotedMinorPiecesY>(reader);
00289   read_count += setUpOne<King25EffectSupported>(reader);
00290   read_count += setUpOne<King25EffectSupportedY>(reader);
00291   read_count += setUpOne<NonPawnAttackedKingRelative>(reader);
00292   read_count += setUpOne<NonPawnAttackedPtype>(reader);
00293   read_count += setUpOne<PtypeCount>(reader);
00294   read_count += setUpOne<KingXBlocked3>(reader);
00295   read_count += setUpOne<KingXBlocked3Y>(reader);
00296   read_count += setUpOne<PtypeCountXY>(reader);
00297   read_count += setUpOne<PtypeCountXYAttack>(reader);
00298   read_count += setUpOne<LanceEffectPieceKingRelative>(reader);
00299   read_count += setUpOne<KingMobility>(reader);
00300   read_count += setUpOne<KingMobilitySum>(reader);
00301   read_count += setUpOne<PtypeYPawnY>(reader);
00302   read_count += setUpOne<GoldAndSilverNearKing>(reader);
00303   read_count += setUpOne<PtypeCombination>(reader);
00304   read_count += setUpOne<PieceStandCombinationBoth>(reader);
00305   read_count += setUpOne<King25BothSide>(reader);
00306   read_count += setUpOne<King25BothSideX>(reader);
00307   read_count += setUpOne<King25BothSideY>(reader);
00308   read_count += setUpOne<GoldAndSilverNearKingCombination>(reader);
00309   read_count += setUpOne<KingMobilityWithRook>(reader);
00310   read_count += setUpOne<KingMobilityWithBishop>(reader);
00311   read_count += setUpOne<NumPiecesBetweenBishopAndKingSelf>(reader);
00312   read_count += setUpOne<NumPiecesBetweenBishopAndKingOpp>(reader);
00313   read_count += setUpOne<NumPiecesBetweenBishopAndKingAll>(reader);
00314   read_count += setUpOne<King25Effect3>(reader);
00315   read_count += setUpOne<SilverHeadPawnKingRelative>(reader);
00316   read_count += setUpOne<GoldKnightKingRelative>(reader);
00317   read_count += setUpOne<RookMobilitySum>(reader);
00318   read_count += setUpOne<RookMobilityX>(reader);
00319   read_count += setUpOne<RookMobilityY>(reader);
00320   read_count += setUpOne<RookMobilitySumKingX>(reader);
00321   read_count += setUpOne<RookMobilityXKingX>(reader);
00322   read_count += setUpOne<PinPtype>(reader);
00323   read_count += setUpOne<PinPtypeDistance>(reader);
00324   read_count += setUpOne<BishopMobilityEach>(reader);
00325   read_count += setUpOne<BishopBishopPiece>(reader);
00326   read_count += setUpOne<NonPawnPieceStandCombination>(reader);
00327   read_count += setUpOne<CanCheckNonPawnPieceStandCombination>(reader);
00328   read_count += setUpOne<King25Effect3Y>(reader);
00329   read_count += setUpOne<RookRook>(reader);
00330   read_count += setUpOne<RookRookPiece>(reader);
00331   read_count += setUpOne<PinPtypePawnAttack>(reader);
00332   read_count += setUpOne<King25Mobility>(reader);
00333   read_count += setUpOne<King25MobilityX>(reader);
00334   read_count += setUpOne<King25MobilityY>(reader);
00335   read_count += setUpOne<King25EffectCountCombination>(reader);
00336   read_count += setUpOne<GoldSideMove>(reader);
00337   read_count += setUpOne<King25EffectCountCombinationY>(reader);
00338   read_count += setUpOne<RookPromoteDefenseRookH>(reader);
00339   read_count += setUpOne<BishopHeadX>(reader);
00340   read_count += setUpOne<PawnDropNonDrop>(reader);
00341   read_count += setUpOne<PawnStateKingRelative>(reader);
00342   read_count += setUpOne<SilverFork>(reader);
00343   read_count += setUpOne<BishopRookFork>(reader);
00344   read_count += setUpOne<BishopStandFile5>(reader);
00345   read_count += setUpOne<KnightFork>(reader);
00346   read_count += setUpOne<NonPawnAttackedPtypePair>(reader);
00347   read_count += setUpOne<MajorCheckWithCapture>(reader);
00348   read_count += setUpOne<SilverAdvance26>(reader);
00349 
00350   initialized_flag = reader.failed() ? Zero : Loaded;
00351   if (initialized_flag != Loaded)
00352   {
00353     std::cerr << "Failed to load OpenMidEndingEval data "
00354               << ' ' << read_count << std::endl;
00355   }
00356   return initialized_flag == Loaded;
00357 }
00358 
00359 bool osl::eval::ml::OpenMidEndingEval::setUp()
00360 {
00361   std::string filename = OslConfig::home();
00362   filename += "/data/eval.bin";
00363   return setUp(filename.c_str());  
00364 }
00365 
00366 osl::eval::ml::
00367 OpenMidEndingEval::OpenMidEndingEval(const NumEffectState &state)
00368   : progress(state), use_progress_independent_value_limit(! OslConfig::hasByoyomi())
00369 {
00370   assert(initialized_flag != Zero);
00371   
00372   pawns.fill(0);
00373   black_pawn_count = 0;
00374   turn = state.turn();
00375   for (int i = PtypeTraits<PAWN>::indexMin;
00376        i < PtypeTraits<PAWN>::indexLimit; ++i)
00377   {
00378     const Piece pawn = state.pieceOf(i);
00379     if (pawn.owner() == BLACK)
00380       ++black_pawn_count;
00381     if (pawn.isOnBoard() && !pawn.isPromoted())
00382       pawns[pawn.owner()][pawn.square().x() - 1] =
00383         pawn.square().y();
00384   }
00385   black_major_count = 0;
00386   black_gold_count = 0;
00387   for (int i = PtypeTraits<ROOK>::indexMin;
00388        i < PtypeTraits<ROOK>::indexLimit; ++i)
00389   {
00390     if (state.pieceOf(i).owner() == BLACK)
00391       ++black_major_count;
00392   }
00393   for (int i = PtypeTraits<BISHOP>::indexMin;
00394        i < PtypeTraits<BISHOP>::indexLimit; ++i)
00395   {
00396     if (state.pieceOf(i).owner() == BLACK)
00397       ++black_major_count;
00398   }
00399   for (int i = PtypeTraits<GOLD>::indexMin;
00400        i < PtypeTraits<GOLD>::indexLimit; ++i)
00401   {
00402     if (state.pieceOf(i).owner() == BLACK)
00403       ++black_gold_count;
00404   }
00405   updateGoldSilverNearKing(state);
00406 
00407   ptype_count.fill(0);
00408   ptypeo_mask=0u;
00409   ptype_board_count.fill(0);
00410   for (int i = 0; i < Piece::SIZE; ++i)
00411   {
00412     const Piece piece = state.pieceOf(i);
00413     if (piece.ptype() == KING)
00414       continue;
00415     ++ptype_count[piece.owner()][piece.ptype()];
00416     ptypeo_mask |= 1<<(piece.ptypeO()-PTYPEO_MIN);
00417     if (piece.isOnBoard())
00418       ++ptype_board_count[piece.owner()][piece.ptype()];
00419   }
00420   non_pawn_stand_count.fill(0);
00421   BOOST_FOREACH(Ptype ptype, osl::PieceStand::order)
00422   {
00423     if (ptype == PAWN)
00424       continue;
00425     non_pawn_stand_count[BLACK] +=
00426       state.countPiecesOnStand(osl::BLACK, ptype);
00427     non_pawn_stand_count[WHITE] += 
00428       state.countPiecesOnStand(osl::WHITE, ptype);
00429   }
00430   progress_independent_value = PieceEval::eval(state);
00431   piece_stand_value = PieceStand::eval(state);
00432   piece_pair_value = PiecePair::eval(state, piece_pair_weights);
00433   piece_pair_king_value = PiecePairKing::eval(state);
00434   RookMobilityAll::eval(state, rook_mobility);
00435   BishopMobilityAll::eval(state, bishop_mobility);
00436   LanceMobilityAll::eval(state, lance_mobility);
00437   knight_advance = KnightAdvance::eval(state);
00438 
00439   rook_effect = RookEffectBase::eval(state);
00440   bishop_effect = BishopEffectBase::eval(state);
00441 
00442   King25EffectEachBoth::eval(state, king25_effect_each);
00443 
00444   King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[WHITE],
00445                                                     effect25_supported[WHITE],
00446                                                     black_attack_effect, black_attack_piece,
00447                                                     white_defense_effect, white_defense_piece,
00448                                                     black_attack_supported_piece,
00449                                                     white_vertical,
00450                                                     white_king_vertical);
00451   King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[BLACK],
00452                                                     effect25_supported[BLACK],
00453                                                     white_attack_effect, white_attack_piece,
00454                                                     black_defense_effect, black_defense_piece,
00455                                                     white_attack_supported_piece,
00456                                                     black_vertical,
00457                                                     black_king_vertical);
00458   recalculated_value =
00459     BishopExchangeSilverKing::eval(state) + 
00460     EnterKingDefense::eval(state) + 
00461     King25EffectAttack::eval(state,
00462                              black_attack_effect,
00463                              black_attack_piece,
00464                              white_attack_effect, white_attack_piece);
00465   recalculated_value +=
00466     King25EffectYAttack::eval(state,
00467                               black_attack_effect,
00468                               black_attack_piece,
00469                               white_attack_effect, white_attack_piece);
00470   kingx_blocked = KingXBothBlocked::eval(state);
00471   {
00472     MultiInt result_supported =
00473       King25EffectSupported::eval(black_attack_piece,
00474                                   white_attack_piece,
00475                                   black_attack_supported_piece,
00476                                   white_attack_supported_piece);
00477     MultiInt result_supported_y =
00478       King25EffectSupportedY::eval(black_attack_piece,
00479                                    white_attack_piece,
00480                                    black_attack_supported_piece,
00481                                    white_attack_supported_piece,
00482                                    state.kingSquare<BLACK>().y(),
00483                                    state.kingSquare<WHITE>().y());
00484 
00485     recalculated_stage_value = result_supported + result_supported_y;
00486     king_rook_bishop[BLACK]=KingRookBishop::evalOne<BLACK>(state);
00487     king_rook_bishop[WHITE]=KingRookBishop::evalOne<WHITE>(state);
00488     recalculated_stage_value+=king_rook_bishop[BLACK]-king_rook_bishop[WHITE];
00489     recalculated_stage_value+=KingXBlocked3::eval(state);
00490   }
00491 
00492   kingx_blocked += KingXBlocked::eval(state)+KingXBlockedY::eval(state);
00493   const MultiInt silver_retreat = SilverFeatures::eval(state);
00494   const MultiInt gold_retreat = GoldFeatures::eval(state);
00495   recalculated_stage_value += knight_advance;
00496   recalculated_stage_value += silver_retreat + gold_retreat;
00497   recalculated_stage_value += AllGold::eval(black_gold_count);
00498   recalculated_stage_value += AllMajor::eval(black_major_count);
00499   recalculated_stage_value += 
00500     King25EffectDefense::eval(state,black_defense_effect,black_defense_piece,
00501                               white_defense_effect, white_defense_piece);
00502   recalculated_stage_value += 
00503     King25EffectYDefense::eval(state,
00504                                black_defense_effect,
00505                                black_defense_piece,
00506                                white_defense_effect, white_defense_piece);
00507   recalculated_stage_value += AnagumaEmpty::eval(state);
00508   recalculated_stage_value += kingx_blocked[BLACK] + kingx_blocked[WHITE];
00509 
00510   recalculated_stage_value += NoPawnOnStand::eval(state, black_pawn_count);
00511   recalculated_stage_value += NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE]);
00512   recalculated_stage_value += PinPtypeAll::eval(state);
00513   recalculated_stage_value += KingMobility::eval(state) + KingMobilitySum::eval(state);
00514   recalculated_stage_value += GoldAndSilverNearKing::eval(state,
00515                                                           gs_near_king_count);
00516   recalculated_stage_value += PtypeCombination::eval(ptypeo_mask);
00517   recalculated_stage_value += PieceStandCombinationBoth::eval(state);
00518   king25_both_side[BLACK]=King25BothSide::evalOne<BLACK>(state,black_vertical);
00519   king25_both_side[WHITE]=King25BothSide::evalOne<WHITE>(state,white_vertical);
00520   recalculated_stage_value += king25_both_side[BLACK]-king25_both_side[WHITE];
00521   recalculated_stage_value += King25Mobility::eval(state,
00522                                                    black_king_vertical,
00523                                                    white_king_vertical);
00524   recalculated_stage_value += BishopStandFile5::eval(state);
00525   recalculated_stage_value += MajorCheckWithCapture::eval(state);
00526   recalculated_stage_value += SilverAdvance26::eval(state);
00527 
00528   king_table_value = KingPieceRelative::eval(state);
00529 
00530   pawn_drop = PawnDropBoth::eval(state);
00531 
00532   ptypex = PtypeX::eval(state);
00533 
00534   ptypey = PtypeY::eval(state);
00535 
00536   can_check[BLACK] =
00537     CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(state);
00538   can_check[WHITE] =
00539     CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(state);
00540   piece_stand_combination = NonPawnPieceStandCombination::eval(state,
00541                                                                can_check);
00542   NonPawnPieceStandTurn::eval(state, piece_stand_turn);
00543   rook_pawn = RookPawnY::eval(state, pawns);
00544   piece_stand_y = PieceStandY::eval(state);
00545 
00546   pawn_advance = PawnAdvance::eval(state);
00547   knight_check = KnightCheck::eval(state);
00548   pawn_ptypeo = PawnPtypeOPtypeO::eval(state);
00549 
00550   promoted_minor_piece = PromotedMinorPieces::eval(state);
00551 
00552   effected_mask[BLACK] =
00553     effected_mask_for_attacked[BLACK] =
00554     state.effectedMask(BLACK);
00555   effected_mask[WHITE] =
00556     effected_mask_for_attacked[WHITE] =
00557     state.effectedMask(WHITE);
00558   mask_t black_ppawn =
00559     effected_mask_for_attacked[BLACK].selectBit<PAWN>() &
00560     state.promotedPieces().getMask<PAWN>();
00561   mask_t white_ppawn =
00562     effected_mask_for_attacked[WHITE].selectBit<PAWN>() &
00563     state.promotedPieces().getMask<PAWN>();
00564   effected_mask_for_attacked[BLACK].clearBit<PAWN>();
00565   effected_mask_for_attacked[WHITE].clearBit<PAWN>();
00566   effected_mask_for_attacked[BLACK].orMask(PtypeFuns<PAWN>::indexNum, black_ppawn);
00567   effected_mask_for_attacked[WHITE].orMask(PtypeFuns<PAWN>::indexNum, white_ppawn);
00568   nosupport = KingPieceRelativeNoSupport::eval(state);
00569   NonPawnAttacked::eval(state, non_pawn_attacked);
00570   NonPawnAttackedPtype::eval(state, attacked_mask, non_pawn_attacked_ptype);
00571   knight_head = KnightHead::eval(state);
00572 
00573   ptype_yy = PtypeYY::eval(state);
00574   king3pieces = King3Pieces::eval(state);
00575   bishop_head = BishopHead::eval(state);
00576   rook_promote_defense = RookPromoteDefense::eval(state);
00577   PtypeCount::eval(state, ptype_count, ptype_board_count, ptype_count_value);
00578   lance_effect_piece = LanceEffectPieceKingRelative::eval(state);
00579   ptype_y_pawn_y = PtypeYPawnY::eval(state, pawns);
00580   bishop_and_king = NumPiecesBetweenBishopAndKing::eval(state);
00581   recalculated_stage_value += King25Effect3::eval(state, effect25);
00582   recalculated_stage_value += BishopBishopPiece::eval(state);
00583   recalculated_stage_value += RookRook::eval(state);
00584   recalculated_stage_value += RookRookPiece::eval(state);
00585   recalculated_stage_value += King25EffectCountCombination::eval(state, effect25);
00586   recalculated_stage_value += NonPawnAttackedPtypePair::eval(state);
00587   piece_fork_turn = SilverFork::eval(state, silver_drop);
00588   piece_fork_turn += BishopRookFork::eval(state, bishop_drop, rook_drop);
00589   piece_fork_turn += KnightFork::eval(state, knight_fork_squares, knight_drop);
00590   invalidateCache();
00591 }
00592 
00593 int osl::eval::ml::
00594 OpenMidEndingEval::expect(const NumEffectState &state, Move move) const
00595 {
00596   if (move.isPass())
00597     return value();
00598   int value;
00599   if(move.player()==BLACK)
00600     value = PieceEval::evalWithUpdate<BLACK>(state, move, progress_independent_value);
00601   else
00602     value = PieceEval::evalWithUpdate<WHITE>(state, move, progress_independent_value);
00603 
00604 #ifdef USE_TEST_PROGRESS
00605   return roundUp(value * NewProgress::maxProgress() +
00606                  openingValue() * (NewProgress::maxProgress() - progress.progress()) + 
00607                  endgameValue() * progress.progress());
00608 #else
00609   return roundUp(value * 16 +
00610                  openingValue() * (16 - progress.progress16().value()) + 
00611                  endgameValue() * progress.progress16().value());
00612 #endif
00613 }
00614 
00615 void osl::eval::ml::
00616 OpenMidEndingEval::update(const NumEffectState &new_state, Move last_move)
00617 {
00618   turn = alt(turn);
00619   assert(new_state.turn() == turn);
00620   if (last_move.isPass())
00621   {
00622     invalidateCache();
00623     return;
00624   }
00625   if(last_move.player()==BLACK)
00626     updateSub<BLACK>(new_state,last_move);
00627   else
00628     updateSub<WHITE>(new_state,last_move);
00629 }
00630 template<osl::Player P>
00631 void osl::eval::ml::
00632 OpenMidEndingEval::updateSub(const NumEffectState &new_state, Move last_move)
00633 {
00634   assert(last_move.player()==P);
00635   const Square opp_king =
00636     new_state.kingSquare<PlayerTraits<P>::opponent>();
00637   const Square self_king =
00638     new_state.kingSquare<P>();
00639   Ptype captured = last_move.capturePtype();
00640   if (captured != PTYPE_EMPTY)
00641   {
00642     Ptype base = unpromote(captured);
00643     if (base == PAWN)
00644     {
00645       if (P == BLACK)
00646         ++black_pawn_count;
00647       else
00648         --black_pawn_count;
00649     }
00650     else
00651     {
00652       ++non_pawn_stand_count[P];
00653     }
00654     if (captured == PAWN)
00655     {
00656       pawns[alt(P)][last_move.to().x() - 1] = 0;
00657     }
00658     if (isMajorBasic(base))
00659     {
00660       if (P == BLACK)
00661         ++black_major_count;
00662       else
00663         --black_major_count;
00664     }
00665     if (base == GOLD)
00666     {
00667       if (P == BLACK)
00668         ++black_gold_count;
00669       else
00670         --black_gold_count;
00671     }
00672     if (base == GOLD || base == SILVER)
00673     {
00674       const int y_diff = std::abs(last_move.to().y() - opp_king.y());
00675       const int x_diff = std::abs(last_move.to().x() - opp_king.x());
00676       if (y_diff <= 2 && x_diff <= 3)
00677       {
00678         --gs_near_king_count[alt(P)][std::max(x_diff, y_diff) - 1];
00679       }
00680     }
00681   }
00682   {
00683     const Ptype base_ptype = unpromote(last_move.ptype());
00684     if (base_ptype == GOLD || base_ptype == SILVER)
00685     {
00686       if (!last_move.isDrop())
00687       {
00688         const int y_diff = std::abs(last_move.from().y() - self_king.y());
00689         const int x_diff = std::abs(last_move.from().x() - self_king.x());
00690         if (y_diff <= 2 && x_diff <= 3)
00691         {
00692           --gs_near_king_count[P][std::max(x_diff, y_diff) - 1];
00693         }
00694       }
00695       {
00696         const int y_diff = std::abs(last_move.to().y() - self_king.y());
00697         const int x_diff = std::abs(last_move.to().x() - self_king.x());
00698         if (y_diff <= 2 && x_diff <= 3)
00699         {
00700           ++gs_near_king_count[P][std::max(x_diff, y_diff) - 1];
00701         }
00702       }
00703     }
00704     if (base_ptype == KING)
00705     {
00706       updateGoldSilverNearKing(new_state);
00707     }
00708   }
00709   if (last_move.isDrop() && last_move.ptype() != PAWN)
00710   {
00711     --non_pawn_stand_count[P];
00712   }
00713   if (last_move.ptype() == PPAWN && last_move.isPromotion())
00714   {
00715     pawns[P][last_move.from().x() - 1] = 0;
00716   }
00717   if (last_move.ptype() == PAWN)
00718   {
00719     pawns[P][last_move.to().x() - 1] = last_move.to().y();
00720   }
00721   const Square kb = new_state.kingSquare<BLACK>(), kw = new_state.kingSquare<WHITE>();
00722   {
00723     BoardMask mask = new_state.changedEffects();
00724     mask.set(last_move.from());
00725     mask.set(last_move.to());
00726     const bool update_black = mask.anyInRange(Board_Mask_Table5x5.mask(kw)); // black attack to white
00727     const bool update_white = mask.anyInRange(Board_Mask_Table5x5.mask(kb));
00728     if (update_black ||
00729         (effect25_supported[WHITE] & new_state.effectedMask(BLACK)) !=
00730         effect25_supported[WHITE] ||
00731         (~effect25_supported[WHITE] & effect25[WHITE] & ~new_state.effectedMask(BLACK)) !=
00732         (~effect25_supported[WHITE] & effect25[WHITE])){
00733       King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
00734         new_state, effect25[WHITE], effect25_supported[WHITE],
00735         black_attack_effect, black_attack_piece,
00736         white_defense_effect, white_defense_piece,
00737         black_attack_supported_piece, white_vertical, white_king_vertical);
00738       king25_both_side[WHITE]=King25BothSide::evalOne<WHITE>(new_state,white_vertical);
00739     }
00740     if (update_white ||
00741         (effect25_supported[BLACK] & new_state.effectedMask(WHITE)) !=
00742         effect25_supported[BLACK] ||
00743         (~effect25_supported[BLACK] & effect25[BLACK] & ~new_state.effectedMask(WHITE)) !=
00744         (~effect25_supported[BLACK] & effect25[BLACK])){
00745       King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
00746         new_state, effect25[BLACK], effect25_supported[BLACK],
00747         white_attack_effect, white_attack_piece,
00748         black_defense_effect, black_defense_piece,
00749         white_attack_supported_piece, black_vertical, black_king_vertical);
00750       king25_both_side[BLACK]=King25BothSide::evalOne<BLACK>(new_state,black_vertical);
00751     }
00752   }
00753 #ifdef USE_TEST_PROGRESS
00754   progress.updateSub<P>(new_state, last_move);
00755 #else
00756   progress.update(new_state, last_move);
00757 #endif
00758 
00759   progress_independent_value =
00760     PieceEval::evalWithUpdate<P>(new_state, last_move, progress_independent_value);
00761   piece_stand_value =
00762     PieceStand::evalWithUpdate<P>(new_state, last_move,
00763                                       piece_stand_value);
00764   if (new_state.longEffectChanged<ROOK>() || last_move.ptype() == KING)
00765   {
00766     RookMobilityAll::eval(new_state, rook_mobility);
00767     rook_effect = RookEffectBase::eval(new_state);
00768   }
00769   if (new_state.longEffectChanged<BISHOP>())
00770   {
00771     BishopMobilityAll::eval(new_state, bishop_mobility);
00772     bishop_effect = BishopEffectBase::eval(new_state);
00773   }
00774   else if (last_move.ptype() == KING)
00775   {
00776     bishop_effect = BishopEffectBase::eval(new_state);
00777   }
00778   if (new_state.longEffectChanged<LANCE>() || last_move.ptype() == KING)
00779   {
00780     LanceMobilityAll::eval(new_state, lance_mobility);
00781     lance_effect_piece = LanceEffectPieceKingRelative::eval(new_state);
00782   }
00783 
00784   if (new_state.anyEffectChanged<KNIGHT>()) {
00785     knight_advance = KnightAdvance::eval(new_state);
00786   }
00787   KingXBlockedBoth::evalWithUpdateBang(new_state, last_move, kingx_blocked);
00788   const MultiInt silver_features = SilverFeatures::eval(new_state);
00789   const MultiInt gold_retreat = GoldFeatures::eval(new_state);
00790   recalculated_stage_value = silver_features+gold_retreat;
00791   recalculated_stage_value += AllGold::eval(black_gold_count);
00792   recalculated_stage_value += AllMajor::eval(black_major_count);
00793   
00794   King25EffectEachBoth::evalWithUpdate(new_state, last_move,
00795                                        king25_effect_each);
00796   
00797   recalculated_value =
00798     BishopExchangeSilverKing::eval(new_state) + 
00799     EnterKingDefense::eval(new_state) + 
00800     King25EffectAttack::eval(new_state,
00801                              black_attack_effect,
00802                              black_attack_piece,
00803                              white_attack_effect, white_attack_piece);
00804   recalculated_value +=
00805     King25EffectYAttack::eval(new_state,
00806                               black_attack_effect,
00807                               black_attack_piece,
00808                               white_attack_effect, white_attack_piece);
00809 
00810   recalculated_stage_value += 
00811     King25EffectDefense::eval(new_state,black_defense_effect,black_defense_piece,
00812                               white_defense_effect, white_defense_piece);
00813   recalculated_stage_value += 
00814     King25EffectYDefense::eval(new_state,
00815                                black_defense_effect,
00816                                black_defense_piece,
00817                                white_defense_effect, white_defense_piece);
00818   recalculated_stage_value += knight_advance;
00819   recalculated_stage_value += AnagumaEmpty::eval(new_state);
00820   recalculated_stage_value += kingx_blocked[BLACK] + kingx_blocked[WHITE];
00821   recalculated_stage_value += NoPawnOnStand::eval(new_state, black_pawn_count);
00822   recalculated_stage_value += NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE]);
00823   recalculated_stage_value += PinPtypeAll::eval(new_state);
00824   recalculated_stage_value += KingMobility::eval(new_state) + KingMobilitySum::eval(new_state);
00825   recalculated_stage_value += GoldAndSilverNearKing::eval(new_state,
00826                                                           gs_near_king_count);
00827   recalculated_stage_value += PieceStandCombinationBoth::eval(new_state);
00828   
00829   {
00830     MultiInt result_supported =
00831       King25EffectSupported::eval(black_attack_piece,
00832                                   white_attack_piece,
00833                                   black_attack_supported_piece,
00834                                   white_attack_supported_piece);
00835     MultiInt result_supported_y =
00836       King25EffectSupportedY::eval(black_attack_piece,
00837                                    white_attack_piece,
00838                                    black_attack_supported_piece,
00839                                    white_attack_supported_piece,
00840                                    new_state.kingSquare<BLACK>().y(),
00841                                    new_state.kingSquare<WHITE>().y());
00842     recalculated_stage_value += result_supported + result_supported_y;
00843     if(isMajorNonPieceOK(last_move.ptype()) || 
00844        isMajorNonPieceOK(last_move.capturePtype())){ // rook or bishop
00845       king_rook_bishop[BLACK]=KingRookBishop::evalOne<BLACK>(new_state);
00846       king_rook_bishop[WHITE]=KingRookBishop::evalOne<WHITE>(new_state);
00847     }
00848     else if(last_move.ptype() == KING){
00849       king_rook_bishop[P]=KingRookBishop::evalOne<P>(new_state);
00850     }
00851     recalculated_stage_value +=king_rook_bishop[BLACK]-king_rook_bishop[WHITE];
00852     recalculated_stage_value += KingXBlocked3::eval(new_state);
00853     recalculated_stage_value += king25_both_side[BLACK]-king25_both_side[WHITE];
00854     recalculated_stage_value += King25Mobility::eval(new_state,
00855                                                      black_king_vertical,
00856                                                      white_king_vertical);
00857   }
00858   king_table_value = KingPieceRelative::evalWithUpdate<P>
00859     (new_state, last_move, king_table_value);
00860   piece_pair_value = PiecePair::evalWithUpdateCompiled(new_state,
00861                                                        last_move,
00862                                                        piece_pair_value);
00863   PiecePairKing::evalWithUpdateBang<P>(new_state, last_move,
00864                                        piece_pair_king_value);
00865   pawn_drop = PawnDropBoth::evalWithUpdate<P>(new_state,
00866                                               last_move, pawn_drop);
00867 
00868   ptypex = PtypeX::evalWithUpdate<P>(new_state, last_move, ptypex);
00869   ptypey = PtypeY::evalWithUpdate<P>(new_state, last_move, ptypey);
00870   CArray<bool, 2> can_check_new;
00871   can_check_new[BLACK] =
00872     CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(new_state);
00873   can_check_new[WHITE] =
00874     CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(new_state);
00875   piece_stand_combination =
00876     NonPawnPieceStandCombination::evalWithUpdate(new_state,
00877                                                  last_move,
00878                                                  piece_stand_combination,
00879                                                  can_check,
00880                                                  can_check_new);
00881   can_check = can_check_new;
00882   NonPawnPieceStandTurn::evalWithUpdateBang<P>(new_state,
00883                                             last_move,
00884                                             piece_stand_turn);
00885   rook_pawn = RookPawnY::eval(new_state, pawns);
00886   piece_stand_y = PieceStandY::evalWithUpdate<P>(new_state, last_move,
00887                                                  piece_stand_y);
00888   PawnAdvanceAll::evalWithUpdateBang<P>(new_state,
00889                                         last_move,
00890                                         pawn_advance);
00891 
00892   knight_check = KnightCheck::eval(new_state);
00893   pawn_ptypeo = PawnPtypeOPtypeO::template evalWithUpdate<P>(new_state, last_move,
00894                                                  pawns,
00895                                                  pawn_ptypeo);
00896 
00897   promoted_minor_piece =
00898     PromotedMinorPieces::evalWithUpdate(new_state,
00899                                         last_move,
00900                                         promoted_minor_piece);
00901 
00902   nosupport = KingPieceRelativeNoSupport::evalWithUpdate(new_state, last_move,
00903                                                          effected_mask,
00904                                                          nosupport);
00905   NonPawnAttacked::evalWithUpdateBang<P>(new_state,
00906                                       last_move,
00907                                       effected_mask_for_attacked,
00908                                       non_pawn_attacked);
00909   NonPawnAttackedPtype::evalWithUpdateBang<P>(
00910     new_state, last_move, effected_mask_for_attacked,
00911     attacked_mask, non_pawn_attacked_ptype);
00912   effected_mask[BLACK] =
00913     effected_mask_for_attacked[BLACK] =
00914     new_state.effectedMask(BLACK);
00915   effected_mask[WHITE] =
00916     effected_mask_for_attacked[WHITE] =
00917     new_state.effectedMask(WHITE);
00918   mask_t black_ppawn =
00919     effected_mask_for_attacked[BLACK].selectBit<PAWN>() &
00920     new_state.promotedPieces().template getMask<PAWN>();
00921   mask_t white_ppawn =
00922     effected_mask_for_attacked[WHITE].selectBit<PAWN>() &
00923     new_state.promotedPieces().template getMask<PAWN>();
00924   effected_mask_for_attacked[BLACK].clearBit<PAWN>();
00925   effected_mask_for_attacked[WHITE].clearBit<PAWN>();
00926   effected_mask_for_attacked[BLACK].orMask(PtypeFuns<PAWN>::indexNum, black_ppawn);
00927   effected_mask_for_attacked[WHITE].orMask(PtypeFuns<PAWN>::indexNum, white_ppawn);
00928 
00929   ptype_yy = PtypeYY::evalWithUpdate(new_state, last_move, ptype_yy);
00930   king3pieces = King3Pieces::evalWithUpdate(new_state, last_move, king3pieces);
00931   bishop_head = BishopHead::eval(new_state);
00932   knight_head = KnightHead::eval(new_state);
00933   rook_promote_defense = RookPromoteDefense::eval(new_state);
00934   PtypeCount::evalWithUpdateBang<P>(new_state,
00935                                  last_move, ptype_count, ptype_board_count,
00936                                  ptype_count_value,ptypeo_mask);
00937   PtypeYPawnY::evalWithUpdateBang<P>(new_state, last_move,pawns, ptype_y_pawn_y);
00938   recalculated_stage_value += PtypeCombination::eval(ptypeo_mask);
00939   bishop_and_king = NumPiecesBetweenBishopAndKing::eval(new_state);
00940   recalculated_stage_value += King25Effect3::eval(new_state, effect25);
00941   recalculated_stage_value += BishopBishopPiece::eval(new_state);
00942   recalculated_stage_value += RookRook::eval(new_state);
00943   recalculated_stage_value += RookRookPiece::eval(new_state);
00944   recalculated_stage_value += King25EffectCountCombination::eval(new_state, effect25);
00945   recalculated_stage_value += BishopStandFile5::eval(new_state);
00946   recalculated_stage_value += MajorCheckWithCapture::eval(new_state);
00947   recalculated_stage_value += SilverAdvance26::eval(new_state);
00948 #ifdef USE_TEST_PROGRESS
00949   recalculated_stage_value += progress.rawData().non_pawn_ptype_attacked_pair_eval[BLACK]
00950     + progress.rawData().non_pawn_ptype_attacked_pair_eval[WHITE];
00951 #else
00952   recalculated_stage_value += NonPawnAttackedPtypePair::eval(new_state);
00953 #endif
00954   piece_fork_turn = SilverFork::eval(new_state, silver_drop);
00955   piece_fork_turn += BishopRookFork::eval(new_state, bishop_drop, rook_drop);
00956   piece_fork_turn += KnightFork::evalWithUpdate<P>(new_state, last_move, knight_fork_squares, knight_drop);
00957   invalidateCache();
00958 }
00959 
00960 #ifndef MINIMAL
00961 osl::eval::ml::OpenMidEndingEvalDebugInfo
00962 osl::eval::ml::OpenMidEndingEval::debugInfo(const NumEffectState &state)
00963 {
00964   OpenMidEndingEvalDebugInfo debug_info;
00965   debug_info.values[OpenMidEndingEvalDebugInfo::EVAL] = value();
00966   debug_info.values[OpenMidEndingEvalDebugInfo::OPENING] = openingValue();
00967   debug_info.values[OpenMidEndingEvalDebugInfo::ENDGAME] = endgameValue();
00968   debug_info.values[OpenMidEndingEvalDebugInfo::PROGRESS_INDEPENDENT] = progressIndependentValue();
00969   debug_info.values[OpenMidEndingEvalDebugInfo::PROGRESS] = progress16().value();
00970   debug_info.values[OpenMidEndingEvalDebugInfo::PIECE] = progress_independent_value;
00971   debug_info.values[OpenMidEndingEvalDebugInfo::ROOK_MOBILITY] = 0; // XXX progress dependent now
00972   debug_info.values[OpenMidEndingEvalDebugInfo::BISHOP_MOBILITY] = 0; // XXX
00973   debug_info.values[OpenMidEndingEvalDebugInfo::LANCE_MOBILITY] = 0; // XXX
00974   int black_attack_effect, black_attack_piece, black_defense_effect, black_defense_piece,
00975     white_attack_effect, white_attack_piece, white_defense_effect, white_defense_piece;
00976   CArray<int, 5> black_vertical, white_vertical,
00977     black_king_vertical, white_king_vertical;
00978   King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[WHITE],
00979                                                     effect25_supported[WHITE],
00980                                                     black_attack_effect, black_attack_piece,
00981                                                     white_defense_effect, white_defense_piece,
00982                                                     black_attack_supported_piece,
00983                                                     white_vertical,
00984                                                     white_king_vertical);
00985   King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[BLACK],
00986                                                     effect25_supported[BLACK],
00987                                                     white_attack_effect, white_attack_piece,
00988                                                     black_defense_effect, black_defense_piece,
00989                                                     white_attack_supported_piece,
00990                                                     black_vertical,
00991                                                     black_king_vertical);
00992   debug_info.values[OpenMidEndingEvalDebugInfo::KING25_EFFECT] =
00993     King25EffectBoth::eval(state,
00994                            black_attack_effect,
00995                            black_attack_piece,
00996                            white_attack_effect, white_attack_piece,
00997                            black_defense_effect, black_defense_piece,
00998                            white_defense_effect, white_defense_piece) +
00999     King25EffectY::eval(state,
01000                         black_attack_effect,
01001                         black_attack_piece,
01002                         white_attack_effect, white_attack_piece,
01003                         black_defense_effect, black_defense_piece,
01004                         white_defense_effect, white_defense_piece);
01005   debug_info.values[OpenMidEndingEvalDebugInfo::PIECE_PAIR] = piece_pair_value;
01006   debug_info.values[OpenMidEndingEvalDebugInfo::KING_PIECE_OPENING] = king_table_value[0];
01007   debug_info.values[OpenMidEndingEvalDebugInfo::KING_PIECE_ENDING] = king_table_value[EndgameIndex];
01008   debug_info.values[OpenMidEndingEvalDebugInfo::PIECE_STAND_OPENING] = piece_stand_value[0];
01009   debug_info.values[OpenMidEndingEvalDebugInfo::PIECE_STAND_ENDING] = piece_stand_value[EndgameIndex];
01010   debug_info.values[OpenMidEndingEvalDebugInfo::KING25_EACH_OPENING] = king25_effect_each[BLACK][0] + king25_effect_each[WHITE][0];
01011   debug_info.values[OpenMidEndingEvalDebugInfo::KING25_EACH_ENDING] = king25_effect_each[WHITE][EndgameIndex] + king25_effect_each[WHITE][EndgameIndex];
01012   debug_info.values[OpenMidEndingEvalDebugInfo::PAWN_DROP_ENDING] = pawn_drop[0];
01013   debug_info.values[OpenMidEndingEvalDebugInfo::PAWN_DROP_ENDING] = pawn_drop[EndgameIndex];
01014   debug_info.values[OpenMidEndingEvalDebugInfo::PTYPE_X_OPENING] = ptypex[0];
01015   debug_info.values[OpenMidEndingEvalDebugInfo::PTYPE_X_ENDING] = ptypex[EndgameIndex];
01016   debug_info.values[OpenMidEndingEvalDebugInfo::PTYPE_Y_OPENING] = ptypey[0];
01017   debug_info.values[OpenMidEndingEvalDebugInfo::PTYPE_Y_ENDING] = ptypey[EndgameIndex];
01018   debug_info.values[OpenMidEndingEvalDebugInfo::NO_PAWN_OPENING] =
01019     NoPawnOnStand::eval(state, black_pawn_count)[0];
01020   debug_info.values[OpenMidEndingEvalDebugInfo::NO_PAWN_ENDING] =
01021     NoPawnOnStand::eval(state, black_pawn_count)[EndgameIndex];
01022   debug_info.values[OpenMidEndingEvalDebugInfo::GOLD_RETREAT_OPENING] =
01023     GoldRetreat::eval(state)[0];
01024   debug_info.values[OpenMidEndingEvalDebugInfo::GOLD_RETREAT_ENDING] =
01025     GoldRetreat::eval(state)[EndgameIndex];
01026 //   debug_info.values[OpenMidEndingEvalDebugInfo::SILVER_RETREAT_OPENING] =
01027 //     SilverRetreat::eval(state)[0];
01028 //   debug_info.values[OpenMidEndingEvalDebugInfo::SILVER_RETREAT_ENDING] =
01029 //     SilverRetreat::eval(state)[EndgameIndex];
01030   debug_info.values[OpenMidEndingEvalDebugInfo::KNIGHT_BLOCKED_OPENING] =
01031     knight_advance[0];
01032   debug_info.values[OpenMidEndingEvalDebugInfo::KNIGHT_BLOCKED_ENDING] =
01033     knight_advance[EndgameIndex];
01034   debug_info.values[OpenMidEndingEvalDebugInfo::KINGX_BLOCKED_OPENING] =
01035     kingx_blocked[BLACK][0] + kingx_blocked[WHITE][0];
01036   debug_info.values[OpenMidEndingEvalDebugInfo::KINGX_BLOCKED_ENDING] =
01037     kingx_blocked[BLACK][EndgameIndex] + kingx_blocked[WHITE][EndgameIndex];
01038   debug_info.values[OpenMidEndingEvalDebugInfo::PIN_OPENING] =
01039     Pin::eval(state, state.pin(BLACK), state.pin(WHITE))[0];
01040   debug_info.values[OpenMidEndingEvalDebugInfo::PIN_ENDING] =
01041     Pin::eval(state, state.pin(BLACK), state.pin(WHITE))[EndgameIndex];
01042   debug_info.values[OpenMidEndingEvalDebugInfo::ALL_GOLD_OPENING] =
01043     AllGold::eval(black_gold_count)[0];
01044   debug_info.values[OpenMidEndingEvalDebugInfo::ALL_GOLD_ENDING] =
01045     AllGold::eval(black_gold_count)[EndgameIndex];
01046   debug_info.values[OpenMidEndingEvalDebugInfo::ANAGUMA_EMPTY_OPENING] =
01047     AnagumaEmpty::eval(state)[0];
01048   debug_info.values[OpenMidEndingEvalDebugInfo::ANAGUMA_EMPTY_ENDING] =
01049     AnagumaEmpty::eval(state)[EndgameIndex];
01050   debug_info.values[OpenMidEndingEvalDebugInfo::STAND_EXCEPT_PAWN_OPENING] =
01051     NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE])[0];
01052   debug_info.values[OpenMidEndingEvalDebugInfo::STAND_EXCEPT_PAWN_ENDING] =
01053     NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE])[EndgameIndex];
01054   return debug_info;
01055 }
01056 
01057 #define DEBUGPRINT(x) std::cerr << "  " << #x << " " << x << "\n"
01058 void osl::eval::ml::OpenMidEndingEval::
01059 debug() const
01060 {
01061   DEBUGPRINT(king_table_value[0]);
01062   DEBUGPRINT(piece_stand_value[0]);
01063   DEBUGPRINT(king25_effect_each[BLACK][0] + king25_effect_each[WHITE][0]);
01064   DEBUGPRINT(ptypex[0]);
01065   DEBUGPRINT(ptypey[0]);
01066   DEBUGPRINT(rook_mobility[0]);
01067   DEBUGPRINT(bishop_mobility[0]);
01068   DEBUGPRINT(lance_mobility[0]);
01069   DEBUGPRINT(rook_effect[0]);
01070   DEBUGPRINT(bishop_effect[0]);
01071   DEBUGPRINT(piece_stand_combination[0]); 
01072   DEBUGPRINT(piece_stand_turn[turn][0]);
01073   DEBUGPRINT(rook_pawn[0]);
01074   DEBUGPRINT(pawn_drop[0]);
01075   DEBUGPRINT(piece_stand_y[0]);
01076   DEBUGPRINT(knight_check[0]);
01077   DEBUGPRINT(pawn_advance[0]);
01078   DEBUGPRINT(pawn_ptypeo[0]);
01079   DEBUGPRINT(promoted_minor_piece[0]);
01080   DEBUGPRINT(nosupport[0]);
01081   DEBUGPRINT(non_pawn_attacked[turn][0]);
01082   DEBUGPRINT(non_pawn_attacked_ptype[turn][0]);
01083   DEBUGPRINT(ptype_yy[0]);
01084   DEBUGPRINT(king3pieces[0]);
01085   DEBUGPRINT(bishop_head[0]);
01086   DEBUGPRINT(knight_head[0]);
01087   DEBUGPRINT(rook_promote_defense[0]);
01088   DEBUGPRINT(ptype_count_value[0]);
01089   DEBUGPRINT(lance_effect_piece[0]);
01090   DEBUGPRINT(ptype_y_pawn_y[0]);
01091   DEBUGPRINT(bishop_and_king[0]);
01092   DEBUGPRINT(recalculated_stage_value[0]);
01093 }
01094 
01095 void osl::eval::ml::OpenMidEndingEval::
01096 setRandom()
01097 {
01098   boost::mutex::scoped_lock lk(initialize_mutex);
01099   initialized_flag = Random;
01100   
01101   setRandomOne<King25EffectAttack>();
01102   setRandomOne<King25EffectYAttack>();
01103 
01104   // opening
01105   setRandomOne<PieceStand>(0);
01106   setRandomOne<Pin>(0);
01107   setRandomOne<King25EffectEachBothOpening>();
01108   setRandomOne<PawnDrop>(0);
01109   setRandomOne<NoPawnOnStand>(0);
01110   setRandomOne<GoldRetreat>(0);
01111   setRandomOne<SilverRetreat>(0);
01112   setRandomOne<KnightAdvance>(0);
01113   setRandomOne<AllMajor>(0);
01114   setRandomOne<KingXBlocked>(0);
01115   setRandomOne<KingXBlockedY>(0);
01116   setRandomOne<AllGold>(0);
01117   setRandomOne<PtypeX>(0);
01118   setRandomOne<PtypeY>(0);
01119   setRandomOne<AnagumaEmpty>(0);
01120   setRandomOne<NonPawnPieceStand>(0);
01121   setRandomOne<King25EffectDefense>(0);
01122   setRandomOne<King25EffectYDefense>(0);
01123   setRandomOne<RookMobility>(0);
01124   setRandomOne<BishopMobility>(0);
01125   setRandomOne<LanceMobility>(0);
01126   setRandomOne<RookEffect>(0);
01127   setRandomOne<BishopEffect>(0);
01128   setRandomOne<PawnAdvance>(0);
01129   setRandomOne<PawnDropY>(0);
01130   setRandomOne<KnightCheck>(0);
01131 
01132   // midgame
01133   setRandomOne<PieceStand>(1);
01134   setRandomOne<Pin>(1);
01135   setRandomOne<King25EffectEachBothMidgame>();
01136   setRandomOne<PawnDrop>(1);
01137   setRandomOne<NoPawnOnStand>(1);
01138   setRandomOne<GoldRetreat>(1);
01139   setRandomOne<SilverRetreat>(1);
01140   setRandomOne<KnightAdvance>(1);
01141   setRandomOne<AllMajor>(1);
01142   setRandomOne<KingXBlocked>(1);
01143   setRandomOne<KingXBlockedY>(1);
01144   setRandomOne<AllGold>(1);
01145   setRandomOne<PtypeX>(1);
01146   setRandomOne<PtypeY>(1);
01147   setRandomOne<AnagumaEmpty>(1);
01148   setRandomOne<NonPawnPieceStand>(1);
01149   setRandomOne<King25EffectDefense>(1);
01150   setRandomOne<King25EffectYDefense>(1);
01151   setRandomOne<RookMobility>(1);
01152   setRandomOne<BishopMobility>(1);
01153   setRandomOne<LanceMobility>(1);
01154   setRandomOne<RookEffect>(1);
01155   setRandomOne<BishopEffect>(1);
01156   setRandomOne<PawnAdvance>(1);
01157   setRandomOne<PawnDropY>(1);
01158   setRandomOne<KnightCheck>(1);
01159 
01160 #ifdef EVAL_QUAD
01161   // midgame2
01162   setRandomOne<PieceStand>(2);
01163   setRandomOne<Pin>(2);
01164   setRandomOne<King25EffectEachBothEnding>();
01165   setRandomOne<PawnDrop>(2);
01166   setRandomOne<NoPawnOnStand>(2);
01167   setRandomOne<GoldRetreat>(2);
01168   setRandomOne<SilverRetreat>(2);
01169   setRandomOne<KnightAdvance>(2);
01170   setRandomOne<AllMajor>(2);
01171   setRandomOne<KingXBlocked>(2);
01172   setRandomOne<KingXBlockedY>(2);
01173   setRandomOne<AllGold>(2);
01174   setRandomOne<PtypeX>(2);
01175   setRandomOne<PtypeY>(2);
01176   setRandomOne<AnagumaEmpty>(2);
01177   setRandomOne<NonPawnPieceStand>(2);
01178   setRandomOne<King25EffectDefense>(2);
01179   setRandomOne<King25EffectYDefense>(2);
01180   setRandomOne<RookMobility>(2);
01181   setRandomOne<BishopMobility>(2);
01182   setRandomOne<LanceMobility>(2);
01183   setRandomOne<RookEffect>(2);
01184   setRandomOne<BishopEffect>(2);
01185   setRandomOne<PawnAdvance>(2);
01186   setRandomOne<PawnDropY>(2);
01187   setRandomOne<KnightCheck>(2);
01188 #endif
01189   // endgame
01190   setRandomOne<PieceStand>(EndgameIndex);
01191   setRandomOne<Pin>(EndgameIndex);
01192   setRandomOne<King25EffectEachBothMidgame>();
01193   setRandomOne<PawnDrop>(EndgameIndex);
01194   setRandomOne<NoPawnOnStand>(EndgameIndex);
01195   setRandomOne<GoldRetreat>(EndgameIndex);
01196   setRandomOne<SilverRetreat>(EndgameIndex);
01197   setRandomOne<KnightAdvance>(EndgameIndex);
01198   setRandomOne<AllMajor>(EndgameIndex);
01199   setRandomOne<KingXBlocked>(EndgameIndex);
01200   setRandomOne<KingXBlockedY>(EndgameIndex);
01201   setRandomOne<AllGold>(EndgameIndex);
01202   setRandomOne<PtypeX>(EndgameIndex);
01203   setRandomOne<PtypeY>(EndgameIndex);
01204   setRandomOne<AnagumaEmpty>(EndgameIndex);
01205   setRandomOne<NonPawnPieceStand>(EndgameIndex);
01206   setRandomOne<King25EffectDefense>(EndgameIndex);
01207   setRandomOne<King25EffectYDefense>(EndgameIndex);
01208   setRandomOne<RookMobility>(EndgameIndex);
01209   setRandomOne<BishopMobility>(EndgameIndex);
01210   setRandomOne<LanceMobility>(EndgameIndex);
01211   setRandomOne<RookEffect>(EndgameIndex);
01212   setRandomOne<BishopEffect>(EndgameIndex);
01213   setRandomOne<PawnAdvance>(EndgameIndex);
01214   setRandomOne<PawnDropY>(EndgameIndex);
01215   setRandomOne<KnightCheck>(EndgameIndex);
01216 
01217   // both
01218   setRandomOne<KingPieceRelative>(0);
01219   setRandomOne<KingPieceRelative>(1);
01220 #ifdef EVAL_QUAD
01221   setRandomOne<KingPieceRelative>(2);
01222 #endif
01223   setRandomOne<KingPieceRelative>(EndgameIndex);
01224   setRandomOne<NonPawnPieceStandCombination>();
01225   setRandomOne<NonPawnPieceStandTurn>();
01226   setRandomOne<King25EffectEachXY>();
01227   setRandomOne<RookPawnY>();
01228   setRandomOne<RookEffectPiece>();
01229   setRandomOne<BishopEffectPiece>();
01230   setRandomOne<PieceStandY>();
01231   setRandomOne<RookEffectPieceKingRelative>();
01232   setRandomOne<BishopEffectPieceKingRelative>();
01233   setRandomOne<RookPawnYX>();
01234   setRandomOne<PawnPtypeOPtypeO>();
01235   setRandomOne<CanCheckNonPawnPieceStandCombination>();
01236   setRandomOne<PromotedMinorPieces>();
01237   setRandomOne<KingPieceRelativeNoSupport>();
01238   setRandomOne<NonPawnAttacked>();
01239   setRandomOne<PtypeYY>();
01240   setRandomOne<PawnPtypeOPtypeOY>();
01241   setRandomOne<PawnDropX>();
01242   setRandomOne<King3Pieces>();
01243   setRandomOne<King3PiecesXY>();
01244   setRandomOne<King25EffectEachKXY>();
01245   setRandomOne<BishopHead>();
01246   setRandomOne<BishopHeadKingRelative>();
01247   setRandomOne<KnightCheckY>();
01248   setRandomOne<KnightHead>();
01249   setRandomOne<RookPromoteDefense>();
01250   setRandomOne<PawnDropPawnStand>();
01251   setRandomOne<PawnDropPawnStandX>();
01252   setRandomOne<PawnDropPawnStandY>();
01253   setRandomOne<King25Effect2>();
01254   setRandomOne<King25EffectY2>();
01255   setRandomOne<KnightHeadOppPiecePawnOnStand>();
01256   setRandomOne<KingXBothBlocked>();
01257   setRandomOne<KingXBothBlockedY>();
01258   setRandomOne<KingRookBishop>();
01259   setRandomOne<PromotedMinorPiecesY>();
01260   setRandomOne<King25EffectSupported>();
01261   setRandomOne<King25EffectSupportedY>();
01262   setRandomOne<NonPawnAttackedKingRelative>();
01263   setRandomOne<NonPawnAttackedPtype>();
01264   setRandomOne<PtypeCount>();
01265   setRandomOne<KingXBlocked3>();
01266   setRandomOne<KingXBlocked3Y>();
01267   setRandomOne<PtypeCountXY>();
01268   setRandomOne<PtypeCountXYAttack>();
01269   setRandomOne<LanceEffectPieceKingRelative>();
01270   setRandomOne<KingMobility>();
01271   setRandomOne<KingMobilitySum>();
01272   setRandomOne<MajorCheckWithCapture>();
01273 
01274 }
01275 #endif
01276 
01277 // ;;; Local Variables:
01278 // ;;; mode:c++
01279 // ;;; c-basic-offset:2
01280 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines