19 #include <boost/foreach.hpp>
20 #include <boost/thread/mutex.hpp>
26 const CArray<int, PTYPE_SIZE> values = {{
28 583, 493, 491, 467, 1279, 1351,
30 128, 318, 361, 540, 959, 1059
38 static const CArray<const char *,PROGRESS_INDEPENDENT_FEATURE_LIMIT> table = {{
40 "BISHOP_EXCHANGE_SILVER_KING",
42 "KING25_EFFECT_ATTACK",
51 static const CArray<const char *,STAGE_FEATURE_LIMIT> table = {{
52 "KING_PIECE_RELATIVE",
62 "PIECE_STAND_COMBINATION",
70 "PROMOTED_MINOR_PIECE",
71 "KING_PIECE_RELATIVE_NOSUPPORT",
73 "NON_PAWN_ATTACKED_PTYPE",
78 "ROOK_PROMOTE_DEFENSE",
85 "BISHOP_SILVER_KNIGHT",
86 "KING25_EFFECT_SUPPORTED",
93 "KING25_EFFECT_DEFENSE",
96 "NON_PAWN_PIECE_STAND",
99 "GOLD_AND_SILVER_NEAR_KING",
103 "BISHOP_STAND_FILE5",
104 "MAJOR_CHECK_WITH_CAPTURE",
107 "BISHOP_BISHOP_PIECE",
110 "KING25_EFFECT_COUNT_COMBINATION",
111 "NON_PAWN_ATTACKED_PTYPE_PAIR",
112 "ATTACK_MAJORS_IN_BASE",
126 template <
class Eval>
127 static void setRandomOne()
130 for (
size_t i = 0; i < weights.
dimension(); ++i)
134 Eval::setUp(weights);
136 template <
class Eval>
137 static void setRandomOne(
int stage)
140 for (
size_t i = 0; i < weights.
dimension(); ++i)
144 Eval::setUp(weights, stage);
147 template <
class Eval,
class Reader>
148 static int setUpOneWithDim(Reader& p,
int dim)
152 for (
size_t i = 0; i < weights.
dimension(); ++i)
159 Eval::setUp(weights);
162 template <
class Eval,
class Reader>
163 static int setUpOne(Reader& p)
165 return setUpOneWithDim<Eval>(p, Eval::DIM);
167 template <
class Eval,
class Reader>
168 static int setUpOne(Reader& p,
int stage)
172 for (
size_t i = 0; i < weights.
dimension(); ++i)
179 Eval::setUp(weights,stage);
195 int read() {
return array[cur++]; }
203 doResetWeights(reader);
209 if (initialized_flag == Loaded)
212 std::ifstream is(filename, std::ios_base::binary);
214 if (! reader.hasNext()) {
215 initialized_flag = Zero;
216 std::cerr <<
"file " << filename << std::endl;
219 doResetWeights(reader);
220 return initialized_flag == Loaded;
223 template <
class Reader>
227 size_t read_count = 0;
230 CArray<int, PTYPE_SIZE> piece_values = {{0}};
234 if (! reader.hasNext())
236 int val = reader.read();
242 piece_values[i] = val;
246 Piece_Value.reset(piece_values);
250 for (
size_t i = 0; i < piece_pair_weights.dimension(); ++i)
252 if (! reader.hasNext())
254 int val = reader.read();
255 piece_pair_weights.setValue(i, val);
261 read_count += setUpOne<King25EffectAttack>(reader);
262 read_count += setUpOne<King25EffectYAttack>(reader);
263 read_count += setUpOne<PiecePairKing>(reader);
264 read_count += setUpOne<BishopExchangeSilverKing>(reader);
265 read_count += setUpOne<EnterKingDefense>(reader);
268 read_count += setUpOne<PieceStand>(reader,0);
269 read_count += setUpOne<King25EffectEachBothOpening>(reader);
270 read_count += setUpOne<PawnDrop>(reader,0);
271 read_count += setUpOne<NoPawnOnStand>(reader,0);
272 read_count += setUpOne<GoldRetreat>(reader,0);
273 read_count += setUpOne<SilverRetreat>(reader,0);
274 read_count += setUpOne<KnightAdvance>(reader,0);
275 read_count += setUpOne<AllMajor>(reader,0);
276 read_count += setUpOne<KingXBlocked>(reader,0);
277 read_count += setUpOne<KingXBlockedY>(reader,0);
278 read_count += setUpOne<AllGold>(reader,0);
279 read_count += setUpOne<PtypeX>(reader,0);
280 read_count += setUpOne<PtypeY>(reader,0);
281 read_count += setUpOne<AnagumaEmpty>(reader,0);
282 read_count += setUpOne<NonPawnPieceStand>(reader,0);
283 read_count += setUpOne<King25EffectDefense>(reader,0);
284 read_count += setUpOne<King25EffectYDefense>(reader,0);
285 read_count += setUpOne<RookMobility>(reader,0);
286 read_count += setUpOne<BishopMobility>(reader,0);
287 read_count += setUpOne<LanceMobility>(reader,0);
288 read_count += setUpOne<RookEffect>(reader,0);
289 read_count += setUpOne<BishopEffect>(reader,0);
290 read_count += setUpOne<PawnAdvance>(reader,0);
291 read_count += setUpOne<PawnDropY>(reader,0);
292 read_count += setUpOne<KnightCheck>(reader,0);
295 read_count += setUpOne<PieceStand>(reader,1);
296 read_count += setUpOne<King25EffectEachBothMidgame>(reader);
297 read_count += setUpOne<PawnDrop>(reader,1);
298 read_count += setUpOne<NoPawnOnStand>(reader,1);
299 read_count += setUpOne<GoldRetreat>(reader,1);
300 read_count += setUpOne<SilverRetreat>(reader,1);
301 read_count += setUpOne<KnightAdvance>(reader,1);
302 read_count += setUpOne<AllMajor>(reader,1);
303 read_count += setUpOne<KingXBlocked>(reader,1);
304 read_count += setUpOne<KingXBlockedY>(reader,1);
305 read_count += setUpOne<AllGold>(reader,1);
306 read_count += setUpOne<PtypeX>(reader,1);
307 read_count += setUpOne<PtypeY>(reader,1);
308 read_count += setUpOne<AnagumaEmpty>(reader,1);
309 read_count += setUpOne<NonPawnPieceStand>(reader,1);
310 read_count += setUpOne<King25EffectDefense>(reader,1);
311 read_count += setUpOne<King25EffectYDefense>(reader,1);
312 read_count += setUpOne<RookMobility>(reader,1);
313 read_count += setUpOne<BishopMobility>(reader,1);
314 read_count += setUpOne<LanceMobility>(reader,1);
315 read_count += setUpOne<RookEffect>(reader,1);
316 read_count += setUpOne<BishopEffect>(reader,1);
317 read_count += setUpOne<PawnAdvance>(reader,1);
318 read_count += setUpOne<PawnDropY>(reader,1);
319 read_count += setUpOne<KnightCheck>(reader,1);
323 read_count += setUpOne<PieceStand>(reader,2);
324 read_count += setUpOne<King25EffectEachBothMidgame2>(reader);
325 read_count += setUpOne<PawnDrop>(reader,2);
326 read_count += setUpOne<NoPawnOnStand>(reader,2);
327 read_count += setUpOne<GoldRetreat>(reader,2);
328 read_count += setUpOne<SilverRetreat>(reader,2);
329 read_count += setUpOne<KnightAdvance>(reader,2);
330 read_count += setUpOne<AllMajor>(reader,2);
331 read_count += setUpOne<KingXBlocked>(reader,2);
332 read_count += setUpOne<KingXBlockedY>(reader,2);
333 read_count += setUpOne<AllGold>(reader,2);
334 read_count += setUpOne<PtypeX>(reader,2);
335 read_count += setUpOne<PtypeY>(reader,2);
336 read_count += setUpOne<AnagumaEmpty>(reader,2);
337 read_count += setUpOne<NonPawnPieceStand>(reader,2);
338 read_count += setUpOne<King25EffectDefense>(reader,2);
339 read_count += setUpOne<King25EffectYDefense>(reader,2);
340 read_count += setUpOne<RookMobility>(reader,2);
341 read_count += setUpOne<BishopMobility>(reader,2);
342 read_count += setUpOne<LanceMobility>(reader,2);
343 read_count += setUpOne<RookEffect>(reader,2);
344 read_count += setUpOne<BishopEffect>(reader,2);
345 read_count += setUpOne<PawnAdvance>(reader,2);
346 read_count += setUpOne<PawnDropY>(reader,2);
347 read_count += setUpOne<KnightCheck>(reader,2);
351 read_count += setUpOne<PieceStand>(reader,
EndgameIndex);
352 read_count += setUpOne<King25EffectEachBothEnding>(reader);
354 read_count += setUpOne<NoPawnOnStand>(reader,
EndgameIndex);
355 read_count += setUpOne<GoldRetreat>(reader,
EndgameIndex);
356 read_count += setUpOne<SilverRetreat>(reader,
EndgameIndex);
357 read_count += setUpOne<KnightAdvance>(reader,
EndgameIndex);
359 read_count += setUpOne<KingXBlocked>(reader,
EndgameIndex);
360 read_count += setUpOne<KingXBlockedY>(reader,
EndgameIndex);
364 read_count += setUpOne<AnagumaEmpty>(reader,
EndgameIndex);
365 read_count += setUpOne<NonPawnPieceStand>(reader,
EndgameIndex);
366 read_count += setUpOne<King25EffectDefense>(reader,
EndgameIndex);
367 read_count += setUpOne<King25EffectYDefense>(reader,
EndgameIndex);
368 read_count += setUpOne<RookMobility>(reader,
EndgameIndex);
369 read_count += setUpOne<BishopMobility>(reader,
EndgameIndex);
370 read_count += setUpOne<LanceMobility>(reader,
EndgameIndex);
371 read_count += setUpOne<RookEffect>(reader,
EndgameIndex);
372 read_count += setUpOne<BishopEffect>(reader,
EndgameIndex);
373 read_count += setUpOne<PawnAdvance>(reader,
EndgameIndex);
375 read_count += setUpOne<KnightCheck>(reader,
EndgameIndex);
378 read_count += setUpOne<KingPieceRelative>(reader,0);
379 read_count += setUpOne<KingPieceRelative>(reader,1);
381 read_count += setUpOne<KingPieceRelative>(reader,2);
383 read_count += setUpOne<KingPieceRelative>(reader,
EndgameIndex);
384 read_count += setUpOne<NonPawnPieceStandTurn>(reader);
385 read_count += setUpOne<King25EffectEachXY>(reader);
386 read_count += setUpOne<RookPawnY>(reader);
387 read_count += setUpOne<RookEffectPiece>(reader);
388 read_count += setUpOne<BishopEffectPiece>(reader);
389 read_count += setUpOne<PieceStandY>(reader);
390 read_count += setUpOne<RookEffectPieceKingRelative>(reader);
391 read_count += setUpOne<BishopEffectPieceKingRelative>(reader);
392 read_count += setUpOne<RookPawnYX>(reader);
393 read_count += setUpOne<PawnPtypeOPtypeO>(reader);
394 read_count += setUpOne<PromotedMinorPieces>(reader);
395 read_count += setUpOne<KingPieceRelativeNoSupport>(reader);
396 read_count += setUpOne<NonPawnAttacked>(reader);
397 read_count += setUpOne<PtypeYY>(reader);
398 read_count += setUpOne<PawnPtypeOPtypeOY>(reader);
399 read_count += setUpOne<PawnDropX>(reader);
400 read_count += setUpOne<King3Pieces>(reader);
401 read_count += setUpOne<King3PiecesXY>(reader);
402 read_count += setUpOne<King25EffectEachKXY>(reader);
403 read_count += setUpOne<BishopHead>(reader);
404 read_count += setUpOne<BishopHeadKingRelative>(reader);
405 read_count += setUpOne<KnightCheckY>(reader);
406 read_count += setUpOne<KnightHead>(reader);
407 read_count += setUpOne<RookPromoteDefense>(reader);
408 read_count += setUpOne<PawnDropPawnStand>(reader);
409 read_count += setUpOne<PawnDropPawnStandX>(reader);
410 read_count += setUpOne<PawnDropPawnStandY>(reader);
411 read_count += setUpOne<KnightHeadOppPiecePawnOnStand>(reader);
412 read_count += setUpOne<KingXBothBlocked>(reader);
413 read_count += setUpOne<KingXBothBlockedY>(reader);
414 read_count += setUpOne<KingRookBishop>(reader);
415 read_count += setUpOne<PromotedMinorPiecesY>(reader);
416 read_count += setUpOne<King25EffectSupported>(reader);
417 read_count += setUpOne<King25EffectSupportedY>(reader);
418 read_count += setUpOne<NonPawnAttackedKingRelative>(reader);
419 read_count += setUpOne<NonPawnAttackedPtype>(reader);
420 read_count += setUpOne<PtypeCount>(reader);
421 read_count += setUpOne<KingXBlocked3>(reader);
422 read_count += setUpOne<KingXBlocked3Y>(reader);
423 read_count += setUpOne<PtypeCountXY>(reader);
424 read_count += setUpOne<PtypeCountXYAttack>(reader);
425 read_count += setUpOne<LanceEffectPieceKingRelative>(reader);
426 read_count += setUpOne<KingMobility>(reader);
427 read_count += setUpOne<KingMobilitySum>(reader);
428 read_count += setUpOne<PtypeYPawnY>(reader);
429 read_count += setUpOne<GoldAndSilverNearKing>(reader);
430 read_count += setUpOne<PtypeCombination>(reader);
431 read_count += setUpOne<PieceStandCombinationBoth>(reader);
432 read_count += setUpOne<King25BothSide>(reader);
433 read_count += setUpOne<King25BothSideX>(reader);
434 read_count += setUpOne<King25BothSideY>(reader);
435 read_count += setUpOne<GoldAndSilverNearKingCombination>(reader);
436 read_count += setUpOne<KingMobilityWithRook>(reader);
437 read_count += setUpOne<KingMobilityWithBishop>(reader);
438 read_count += setUpOne<NumPiecesBetweenBishopAndKingSelf>(reader);
439 read_count += setUpOne<NumPiecesBetweenBishopAndKingOpp>(reader);
440 read_count += setUpOne<NumPiecesBetweenBishopAndKingAll>(reader);
441 read_count += setUpOne<King25Effect3>(reader);
442 read_count += setUpOne<SilverHeadPawnKingRelative>(reader);
443 read_count += setUpOne<GoldKnightKingRelative>(reader);
444 read_count += setUpOne<RookMobilitySum>(reader);
445 read_count += setUpOne<RookMobilityX>(reader);
446 read_count += setUpOne<RookMobilityY>(reader);
447 read_count += setUpOne<RookMobilitySumKingX>(reader);
448 read_count += setUpOne<RookMobilityXKingX>(reader);
449 read_count += setUpOne<PinPtype>(reader);
450 read_count += setUpOne<PinPtypeDistance>(reader);
451 read_count += setUpOne<BishopMobilityEach>(reader);
452 read_count += setUpOne<BishopBishopPiece>(reader);
453 read_count += setUpOne<NonPawnPieceStandCombination>(reader);
454 read_count += setUpOne<CanCheckNonPawnPieceStandCombination>(reader);
455 read_count += setUpOne<King25Effect3Y>(reader);
456 read_count += setUpOne<RookRook>(reader);
457 read_count += setUpOne<RookRookPiece>(reader);
458 read_count += setUpOne<PinPtypePawnAttack>(reader);
459 read_count += setUpOne<King25Mobility>(reader);
460 read_count += setUpOne<King25MobilityX>(reader);
461 read_count += setUpOne<King25MobilityY>(reader);
462 read_count += setUpOne<King25EffectCountCombination>(reader);
463 read_count += setUpOne<GoldSideMove>(reader);
464 read_count += setUpOne<King25EffectCountCombinationY>(reader);
465 read_count += setUpOne<RookPromoteDefenseRookH>(reader);
466 read_count += setUpOne<BishopHeadX>(reader);
467 read_count += setUpOne<PawnDropNonDrop>(reader);
468 read_count += setUpOne<PawnStateKingRelative>(reader);
469 read_count += setUpOne<SilverFork>(reader);
470 read_count += setUpOne<BishopRookFork>(reader);
471 read_count += setUpOne<BishopStandFile5>(reader);
472 read_count += setUpOne<KnightFork>(reader);
473 read_count += setUpOne<NonPawnAttackedPtypePair>(reader);
474 read_count += setUpOne<MajorCheckWithCapture>(reader);
475 read_count += setUpOne<SilverAdvance26>(reader);
476 read_count += setUpOne<RookSilverKnight>(reader);
477 read_count += setUpOne<BishopSilverKnight>(reader);
478 read_count += setUpOne<AttackMajorsInBase>(reader);
479 read_count += setUpOne<CheckShadowPtype>(reader);
480 read_count += setUpOne<Promotion37>(reader);
482 initialized_flag = reader.failed() ? Zero : Loaded;
483 if (initialized_flag != Loaded)
485 std::cerr <<
"Failed to load OpenMidEndingEval data "
486 <<
' ' << read_count << std::endl;
493 filename +=
"/data/eval.bin";
499 return setUp(defaultFilename().c_str());
504 : progress(state), use_progress_independent_value_limit(use_limit)
512 i < PtypeTraits<PAWN>::indexLimit; ++i)
514 const Piece pawn = state.pieceOf(i);
524 i < PtypeTraits<ROOK>::indexLimit; ++i)
526 if (state.pieceOf(i).owner() ==
BLACK)
530 i < PtypeTraits<BISHOP>::indexLimit; ++i)
532 if (state.pieceOf(i).owner() ==
BLACK)
536 i < PtypeTraits<GOLD>::indexLimit; ++i)
538 if (state.pieceOf(i).owner() ==
BLACK)
548 const Piece piece = state.pieceOf(i);
580 King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state,
effect25[
WHITE],
587 King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[
BLACK],
588 effect25_supported[
BLACK],
600 white_attack_effect, white_attack_piece);
601 recalculated_value +=
605 white_attack_effect, white_attack_piece);
611 black_attack_supported_piece,
612 white_attack_supported_piece);
616 black_attack_supported_piece,
617 white_attack_supported_piece,
618 state.kingSquare<
BLACK>().y(),
619 state.kingSquare<
WHITE>().y());
624 recalculated_stage_value+=king_rook_bishop[
BLACK]-king_rook_bishop[
WHITE];
637 white_defense_effect, white_defense_piece);
640 black_defense_effect,
642 white_defense_effect, white_defense_piece);
673 CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(state);
675 CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(state);
690 state.effectedMask(BLACK);
693 state.effectedMask(WHITE);
696 state.promotedPieces().getMask<
PAWN>();
699 state.promotedPieces().getMask<
PAWN>();
741 value = PieceEval::evalWithUpdate<BLACK>(state, move, progress_independent_value);
743 value = PieceEval::evalWithUpdate<WHITE>(state, move, progress_independent_value);
745 #ifdef USE_TEST_PROGRESS
748 endgameValue() * progress.progress());
750 return roundUp(value * 16 +
751 openingValue() * (16 - progress.progress16().value()) +
752 endgameValue() * progress.progress16().value());
760 assert(new_state.turn() == turn);
767 updateSub<BLACK>(new_state,last_move);
769 updateSub<WHITE>(new_state,last_move);
771 template<osl::Player P>
775 assert(last_move.
player()==P);
779 new_state.kingSquare<P>();
793 ++non_pawn_stand_count[P];
795 if (captured ==
PAWN)
797 pawns[
alt(P)][last_move.
to().
x() - 1] = 0;
815 const int y_diff = std::abs(last_move.
to().
y() - opp_king.y());
816 const int x_diff = std::abs(last_move.
to().
x() - opp_king.x());
817 if (y_diff <= 2 && x_diff <= 3)
819 --gs_near_king_count[
alt(P)][
std::max(x_diff, y_diff) - 1];
825 if (base_ptype ==
GOLD || base_ptype ==
SILVER)
829 const int y_diff = std::abs(last_move.
from().
y() - self_king.y());
830 const int x_diff = std::abs(last_move.
from().
x() - self_king.x());
831 if (y_diff <= 2 && x_diff <= 3)
833 --gs_near_king_count[P][
std::max(x_diff, y_diff) - 1];
837 const int y_diff = std::abs(last_move.
to().
y() - self_king.y());
838 const int x_diff = std::abs(last_move.
to().
x() - self_king.x());
839 if (y_diff <= 2 && x_diff <= 3)
841 ++gs_near_king_count[P][
std::max(x_diff, y_diff) - 1];
845 if (base_ptype ==
KING)
847 updateGoldSilverNearKing(new_state);
852 --non_pawn_stand_count[P];
856 pawns[P][last_move.
from().
x() - 1] = 0;
860 pawns[P][last_move.
to().
x() - 1] = last_move.
to().
y();
862 const Square kb = new_state.kingSquare<
BLACK>(), kw = new_state.kingSquare<
WHITE>();
864 BoardMask mask = new_state.changedEffects();
865 mask.set(last_move.
from());
866 mask.set(last_move.
to());
870 (effect25_supported[
WHITE] & new_state.effectedMask(
BLACK)) !=
871 effect25_supported[
WHITE] ||
872 (~effect25_supported[
WHITE] & effect25[
WHITE] & ~new_state.effectedMask(
BLACK)) !=
873 (~effect25_supported[
WHITE] & effect25[
WHITE])){
874 King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
875 new_state, effect25[
WHITE], effect25_supported[
WHITE],
876 black_attack_effect, black_attack_piece,
877 white_defense_effect, white_defense_piece,
878 black_attack_supported_piece, white_vertical, white_king_vertical);
879 king25_both_side[
WHITE]=King25BothSide::evalOne<WHITE>(new_state,white_vertical);
882 (effect25_supported[
BLACK] & new_state.effectedMask(WHITE)) !=
883 effect25_supported[
BLACK] ||
884 (~effect25_supported[
BLACK] & effect25[
BLACK] & ~new_state.effectedMask(WHITE)) !=
885 (~effect25_supported[
BLACK] & effect25[
BLACK])){
886 King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
887 new_state, effect25[
BLACK], effect25_supported[
BLACK],
888 white_attack_effect, white_attack_piece,
889 black_defense_effect, black_defense_piece,
890 white_attack_supported_piece, black_vertical, black_king_vertical);
891 king25_both_side[
BLACK]=King25BothSide::evalOne<BLACK>(new_state,black_vertical);
894 #ifdef USE_TEST_PROGRESS
895 progress.updateSub<P>(new_state, last_move);
897 progress.update(new_state, last_move);
900 progress_independent_value =
901 PieceEval::evalWithUpdate<P>(new_state, last_move, progress_independent_value);
903 PieceStand::evalWithUpdate<P>(new_state, last_move,
905 if (new_state.longEffectChanged<
ROOK>() || last_move.ptype() ==
KING)
910 if (new_state.longEffectChanged<
BISHOP>())
915 else if (last_move.ptype() ==
KING)
919 if (new_state.longEffectChanged<
LANCE>() || last_move.ptype() ==
KING)
925 if (new_state.anyEffectChanged<
KNIGHT>()) {
931 recalculated_stage_value = silver_features+gold_retreat;
944 white_attack_effect, white_attack_piece);
945 recalculated_value +=
949 white_attack_effect, white_attack_piece);
951 recalculated_stage_value +=
953 white_defense_effect, white_defense_piece);
954 recalculated_stage_value +=
956 black_defense_effect,
958 white_defense_effect, white_defense_piece);
959 recalculated_stage_value += knight_advance;
961 recalculated_stage_value += kingx_blocked[
BLACK] + kingx_blocked[
WHITE];
974 black_attack_supported_piece,
975 white_attack_supported_piece);
979 black_attack_supported_piece,
980 white_attack_supported_piece,
981 new_state.kingSquare<BLACK>().y(),
982 new_state.kingSquare<WHITE>().y());
983 recalculated_stage_value += result_supported + result_supported_y;
986 king_rook_bishop[
BLACK]=KingRookBishop::evalOne<BLACK>(new_state);
987 king_rook_bishop[
WHITE]=KingRookBishop::evalOne<WHITE>(new_state);
989 else if(last_move.ptype() ==
KING){
990 king_rook_bishop[P]=KingRookBishop::evalOne<P>(new_state);
992 recalculated_stage_value +=king_rook_bishop[
BLACK]-king_rook_bishop[
WHITE];
994 recalculated_stage_value += king25_both_side[
BLACK]-king25_both_side[
WHITE];
997 white_king_vertical);
999 king_table_value = KingPieceRelative::evalWithUpdate<P>
1000 (new_state, last_move, king_table_value);
1004 PiecePairKing::evalWithUpdateBang<P>(new_state, last_move,
1005 piece_pair_king_value);
1006 pawn_drop = PawnDropBoth::evalWithUpdate<P>(new_state,
1007 last_move, pawn_drop);
1009 ptypex = PtypeX::evalWithUpdate<P>(new_state, last_move, ptypex);
1010 ptypey = PtypeY::evalWithUpdate<P>(new_state, last_move, ptypey);
1011 CArray<bool, 2> can_check_new;
1012 can_check_new[
BLACK] =
1013 CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(new_state);
1014 can_check_new[
WHITE] =
1015 CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(new_state);
1016 piece_stand_combination =
1019 piece_stand_combination,
1022 can_check = can_check_new;
1023 NonPawnPieceStandTurn::evalWithUpdateBang<P>(new_state,
1027 piece_stand_y = PieceStandY::evalWithUpdate<P>(new_state, last_move,
1029 PawnAdvanceAll::evalWithUpdateBang<P>(new_state,
1034 pawn_ptypeo = PawnPtypeOPtypeO::template evalWithUpdate<P>(new_state, last_move,
1038 promoted_minor_piece =
1041 promoted_minor_piece);
1046 NonPawnAttacked::evalWithUpdateBang<P>(new_state,
1048 effected_mask_for_attacked,
1050 NonPawnAttackedPtype::evalWithUpdateBang<P>(
1051 new_state, last_move, effected_mask_for_attacked,
1052 attacked_mask, non_pawn_attacked_ptype);
1053 effected_mask[
BLACK] =
1054 effected_mask_for_attacked[
BLACK] =
1055 new_state.effectedMask(BLACK);
1056 effected_mask[
WHITE] =
1057 effected_mask_for_attacked[
WHITE] =
1058 new_state.effectedMask(WHITE);
1060 effected_mask_for_attacked[
BLACK].selectBit<
PAWN>() &
1061 new_state.promotedPieces().template getMask<PAWN>();
1063 effected_mask_for_attacked[
WHITE].selectBit<
PAWN>() &
1064 new_state.promotedPieces().template getMask<PAWN>();
1065 effected_mask_for_attacked[
BLACK].clearBit<
PAWN>();
1066 effected_mask_for_attacked[
WHITE].clearBit<
PAWN>();
1075 PtypeCount::evalWithUpdateBang<P>(new_state,
1076 last_move, ptype_count, ptype_board_count,
1077 ptype_count_value,ptypeo_mask);
1078 PtypeYPawnY::evalWithUpdateBang<P>(new_state, last_move,pawns, ptype_y_pawn_y);
1089 if (base_ptype ==
ROOK || last_move.ptype() ==
SILVER ||
1090 last_move.ptype() ==
KNIGHT ||
1093 (last_move.isPromotion() &&
1098 if (base_ptype ==
BISHOP || last_move.ptype() ==
SILVER ||
1099 last_move.ptype() ==
KNIGHT ||
1102 (last_move.isPromotion() &&
1109 #ifdef USE_TEST_PROGRESS
1110 recalculated_stage_value += progress.rawData().promotion37_eval;
1111 recalculated_stage_value += progress.rawData().non_pawn_ptype_attacked_pair_eval[
BLACK]
1112 + progress.rawData().non_pawn_ptype_attacked_pair_eval[
WHITE];
1119 piece_fork_turn += KnightFork::evalWithUpdate<P>(new_state, last_move, knight_fork_squares, knight_drop);
1128 debug_info.
value = value();
1129 debug_info.
progress = progress16().value();
1135 int black_attack_effect, black_attack_piece, black_defense_effect, black_defense_piece,
1136 white_attack_effect, white_attack_piece, white_defense_effect, white_defense_piece;
1137 CArray<int, 5> black_vertical, white_vertical,
1138 black_king_vertical, white_king_vertical;
1139 King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[
WHITE],
1140 effect25_supported[
WHITE],
1141 black_attack_effect, black_attack_piece,
1142 white_defense_effect, white_defense_piece,
1143 black_attack_supported_piece,
1145 white_king_vertical);
1146 King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[
BLACK],
1147 effect25_supported[
BLACK],
1148 white_attack_effect, white_attack_piece,
1149 black_defense_effect, black_defense_piece,
1150 white_attack_supported_piece,
1152 black_king_vertical);
1155 black_attack_effect,
1157 white_attack_effect, white_attack_piece,
1158 black_defense_effect, black_defense_piece,
1159 white_defense_effect, white_defense_piece) +
1161 black_attack_effect,
1163 white_attack_effect, white_attack_piece,
1164 black_defense_effect, black_defense_piece,
1165 white_defense_effect, white_defense_piece);
1174 king25_effect_each[
BLACK] + king25_effect_each[
WHITE];
1209 black_attack_supported_piece,
1210 white_attack_supported_piece) +
1213 black_attack_supported_piece,
1214 white_attack_supported_piece,
1215 state.kingSquare<
BLACK>().y(),
1216 state.kingSquare<
WHITE>().y());
1218 king_rook_bishop[
BLACK] - king_rook_bishop[
WHITE];
1231 white_defense_effect, white_defense_piece) +
1233 black_defense_effect,
1234 black_defense_piece,
1235 white_defense_effect, white_defense_piece);
1248 gs_near_king_count);
1252 king25_both_side[
BLACK] - king25_both_side[
WHITE];
1255 black_king_vertical,
1256 white_king_vertical);
1281 #define DEBUGPRINT(x) std::cerr << " " << #x << " " << x << "\n"
1306 DEBUGPRINT(non_pawn_attacked_ptype[turn][0]);
1323 initialized_flag = Random;
1325 setRandomOne<King25EffectAttack>();
1326 setRandomOne<King25EffectYAttack>();
1329 setRandomOne<PieceStand>(0);
1330 setRandomOne<Pin>(0);
1331 setRandomOne<King25EffectEachBothOpening>();
1332 setRandomOne<PawnDrop>(0);
1333 setRandomOne<NoPawnOnStand>(0);
1334 setRandomOne<GoldRetreat>(0);
1335 setRandomOne<SilverRetreat>(0);
1336 setRandomOne<KnightAdvance>(0);
1337 setRandomOne<AllMajor>(0);
1338 setRandomOne<KingXBlocked>(0);
1339 setRandomOne<KingXBlockedY>(0);
1340 setRandomOne<AllGold>(0);
1341 setRandomOne<PtypeX>(0);
1342 setRandomOne<PtypeY>(0);
1343 setRandomOne<AnagumaEmpty>(0);
1344 setRandomOne<NonPawnPieceStand>(0);
1345 setRandomOne<King25EffectDefense>(0);
1346 setRandomOne<King25EffectYDefense>(0);
1347 setRandomOne<RookMobility>(0);
1348 setRandomOne<BishopMobility>(0);
1349 setRandomOne<LanceMobility>(0);
1350 setRandomOne<RookEffect>(0);
1351 setRandomOne<BishopEffect>(0);
1352 setRandomOne<PawnAdvance>(0);
1353 setRandomOne<PawnDropY>(0);
1354 setRandomOne<KnightCheck>(0);
1357 setRandomOne<PieceStand>(1);
1358 setRandomOne<Pin>(1);
1359 setRandomOne<King25EffectEachBothMidgame>();
1360 setRandomOne<PawnDrop>(1);
1361 setRandomOne<NoPawnOnStand>(1);
1362 setRandomOne<GoldRetreat>(1);
1363 setRandomOne<SilverRetreat>(1);
1364 setRandomOne<KnightAdvance>(1);
1365 setRandomOne<AllMajor>(1);
1366 setRandomOne<KingXBlocked>(1);
1367 setRandomOne<KingXBlockedY>(1);
1368 setRandomOne<AllGold>(1);
1369 setRandomOne<PtypeX>(1);
1370 setRandomOne<PtypeY>(1);
1371 setRandomOne<AnagumaEmpty>(1);
1372 setRandomOne<NonPawnPieceStand>(1);
1373 setRandomOne<King25EffectDefense>(1);
1374 setRandomOne<King25EffectYDefense>(1);
1375 setRandomOne<RookMobility>(1);
1376 setRandomOne<BishopMobility>(1);
1377 setRandomOne<LanceMobility>(1);
1378 setRandomOne<RookEffect>(1);
1379 setRandomOne<BishopEffect>(1);
1380 setRandomOne<PawnAdvance>(1);
1381 setRandomOne<PawnDropY>(1);
1382 setRandomOne<KnightCheck>(1);
1386 setRandomOne<PieceStand>(2);
1387 setRandomOne<Pin>(2);
1388 setRandomOne<King25EffectEachBothEnding>();
1389 setRandomOne<PawnDrop>(2);
1390 setRandomOne<NoPawnOnStand>(2);
1391 setRandomOne<GoldRetreat>(2);
1392 setRandomOne<SilverRetreat>(2);
1393 setRandomOne<KnightAdvance>(2);
1394 setRandomOne<AllMajor>(2);
1395 setRandomOne<KingXBlocked>(2);
1396 setRandomOne<KingXBlockedY>(2);
1397 setRandomOne<AllGold>(2);
1398 setRandomOne<PtypeX>(2);
1399 setRandomOne<PtypeY>(2);
1400 setRandomOne<AnagumaEmpty>(2);
1401 setRandomOne<NonPawnPieceStand>(2);
1402 setRandomOne<King25EffectDefense>(2);
1403 setRandomOne<King25EffectYDefense>(2);
1404 setRandomOne<RookMobility>(2);
1405 setRandomOne<BishopMobility>(2);
1406 setRandomOne<LanceMobility>(2);
1407 setRandomOne<RookEffect>(2);
1408 setRandomOne<BishopEffect>(2);
1409 setRandomOne<PawnAdvance>(2);
1410 setRandomOne<PawnDropY>(2);
1411 setRandomOne<KnightCheck>(2);
1416 setRandomOne<King25EffectEachBothMidgame>();
1442 setRandomOne<KingPieceRelative>(0);
1443 setRandomOne<KingPieceRelative>(1);
1445 setRandomOne<KingPieceRelative>(2);
1448 setRandomOne<NonPawnPieceStandCombination>();
1449 setRandomOne<NonPawnPieceStandTurn>();
1450 setRandomOne<King25EffectEachXY>();
1451 setRandomOne<RookPawnY>();
1452 setRandomOne<RookEffectPiece>();
1453 setRandomOne<BishopEffectPiece>();
1454 setRandomOne<PieceStandY>();
1455 setRandomOne<RookEffectPieceKingRelative>();
1456 setRandomOne<BishopEffectPieceKingRelative>();
1457 setRandomOne<RookPawnYX>();
1458 setRandomOne<PawnPtypeOPtypeO>();
1459 setRandomOne<CanCheckNonPawnPieceStandCombination>();
1460 setRandomOne<PromotedMinorPieces>();
1461 setRandomOne<KingPieceRelativeNoSupport>();
1462 setRandomOne<NonPawnAttacked>();
1463 setRandomOne<PtypeYY>();
1464 setRandomOne<PawnPtypeOPtypeOY>();
1465 setRandomOne<PawnDropX>();
1466 setRandomOne<King3Pieces>();
1467 setRandomOne<King3PiecesXY>();
1468 setRandomOne<King25EffectEachKXY>();
1469 setRandomOne<BishopHead>();
1470 setRandomOne<BishopHeadKingRelative>();
1471 setRandomOne<KnightCheckY>();
1472 setRandomOne<KnightHead>();
1473 setRandomOne<RookPromoteDefense>();
1474 setRandomOne<PawnDropPawnStand>();
1475 setRandomOne<PawnDropPawnStandX>();
1476 setRandomOne<PawnDropPawnStandY>();
1477 setRandomOne<King25Effect2>();
1478 setRandomOne<King25EffectY2>();
1479 setRandomOne<KnightHeadOppPiecePawnOnStand>();
1480 setRandomOne<KingXBothBlocked>();
1481 setRandomOne<KingXBothBlockedY>();
1482 setRandomOne<KingRookBishop>();
1483 setRandomOne<PromotedMinorPiecesY>();
1484 setRandomOne<King25EffectSupported>();
1485 setRandomOne<King25EffectSupportedY>();
1486 setRandomOne<NonPawnAttackedKingRelative>();
1487 setRandomOne<NonPawnAttackedPtype>();
1488 setRandomOne<PtypeCount>();
1489 setRandomOne<KingXBlocked3>();
1490 setRandomOne<KingXBlocked3Y>();
1491 setRandomOne<PtypeCountXY>();
1492 setRandomOne<PtypeCountXYAttack>();
1493 setRandomOne<LanceEffectPieceKingRelative>();
1494 setRandomOne<KingMobility>();
1495 setRandomOne<KingMobilitySum>();
1496 setRandomOne<MajorCheckWithCapture>();
1497 setRandomOne<RookSilverKnight>();
1498 setRandomOne<BishopSilverKnight>();
1506 EffectUtil::findThreat<osl::eval::ml::OpenMidEndingEval>(
1507 const NumEffectState& state,