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