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