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