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