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