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