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