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
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
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
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
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
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
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
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
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));
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())){
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
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
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
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
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
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
01514
01515
01516