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