Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { Key key = pos.material_key(); Entry* e = entries[key]; // If e->key matches the position's material hash key, it means that we // have analysed this material configuration before, and we can simply // return the information we found the last time instead of recomputing it. if (e->key == key) return e; std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; e->gamePhase = game_phase(pos); // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then // for a generic one if the previous search failed. if (endgames.probe(key, e->evaluationFunction)) return e; if (is_KXK<WHITE>(pos)) { e->evaluationFunction = &EvaluateKXK[WHITE]; return e; } if (is_KXK<BLACK>(pos)) { e->evaluationFunction = &EvaluateKXK[BLACK]; return e; } if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN)) { // Minor piece endgame with at least one minor piece per side and // no pawns. Note that the case KmmK is already handled by KXK. assert((pos.pieces(WHITE, KNIGHT) | pos.pieces(WHITE, BISHOP))); assert((pos.pieces(BLACK, KNIGHT) | pos.pieces(BLACK, BISHOP))); if ( pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE) <= 2 && pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK) <= 2) { e->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()]; return e; } } // OK, we didn't find any special evaluation function for the current // material configuration. Is there a suitable scaling function? // // We face problems when there are several conflicting applicable // scaling functions and we need to decide which one to use. EndgameBase<ScaleFactor>* sf; if (endgames.probe(key, sf)) { e->scalingFunction[sf->color()] = sf; return e; } // Generic scaling functions that refer to more then one material // distribution. They should be probed after the specialized ones. // Note that these ones don't return after setting the function. if (is_KBPsKs<WHITE>(pos)) e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE]; if (is_KBPsKs<BLACK>(pos)) e->scalingFunction[BLACK] = &ScaleKBPsK[BLACK]; if (is_KQKRPs<WHITE>(pos)) e->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE]; else if (is_KQKRPs<BLACK>(pos)) e->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK]; Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); if (npm_w + npm_b == VALUE_ZERO) { if (!pos.count<PAWN>(BLACK)) { assert(pos.count<PAWN>(WHITE) >= 2); e->scalingFunction[WHITE] = &ScaleKPsK[WHITE]; } else if (!pos.count<PAWN>(WHITE)) { assert(pos.count<PAWN>(BLACK) >= 2); e->scalingFunction[BLACK] = &ScaleKPsK[BLACK]; } else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1) { // This is a special case because we set scaling functions // for both colors instead of only one. e->scalingFunction[WHITE] = &ScaleKPKP[WHITE]; e->scalingFunction[BLACK] = &ScaleKPKP[BLACK]; } } // No pawns makes it difficult to win, even with a material advantage. This // catches some trivial draws like KK, KBK and KNK if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg) { e->factor[WHITE] = (uint8_t) (npm_w == npm_b || npm_w < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(WHITE), 2)]); } if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg) { e->factor[BLACK] = (uint8_t) (npm_w == npm_b || npm_b < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(BLACK), 2)]); } // Compute the space weight if (npm_w + npm_b >= 2 * QueenValueMg + 4 * RookValueMg + 2 * KnightValueMg) { int minorPieceCount = pos.count<KNIGHT>(WHITE) + pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(BLACK) + pos.count<BISHOP>(BLACK); e->spaceWeight = make_score(minorPieceCount * minorPieceCount, 0); } // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE), pos.count<BISHOP>(WHITE) , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) }, { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK), pos.count<BISHOP>(BLACK) , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } }; e->value = (int16_t)((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16); // Having pawn(s) and ahead at least a piece (npm) ==> Exchange Pieces not Pawns ! if (npm_w >= (npm_b + 3*PawnValueMg) && pos.count<PAWN>(WHITE) && pos.count<PAWN>(WHITE) > pos.count<PAWN>(BLACK) - 3) e->value += (int16_t)((imbalanceWinning<WHITE>(pieceCount) - imbalanceLoosing<BLACK>(pieceCount)) / 16); if (npm_b >= (npm_w + 3*PawnValueMg) && pos.count<PAWN>(BLACK) && pos.count<PAWN>(BLACK) > pos.count<PAWN>(WHITE) - 3) e->value += (int16_t)((imbalanceWinning<BLACK>(pieceCount) - imbalanceLoosing<WHITE>(pieceCount)) / 16); return e; }
Entry* probe(const Position& pos) { Key key = pos.material_key(); Entry* e = pos.this_thread()->materialTable[key]; if (e->key == key) return e; std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; e->gamePhase = pos.game_phase(); // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then // for a generic one if the previous search failed. if ((e->evaluationFunction = pos.this_thread()->endgames.probe<Value>(key)) != nullptr) return e; for (Color c = WHITE; c <= BLACK; ++c) if (is_KXK(pos, c)) { e->evaluationFunction = &EvaluateKXK[c]; return e; } // OK, we didn't find any special evaluation function for the current material // configuration. Is there a suitable specialized scaling function? EndgameBase<ScaleFactor>* sf; if ((sf = pos.this_thread()->endgames.probe<ScaleFactor>(key)) != nullptr) { e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned return e; } // We didn't find any specialized scaling function, so fall back on generic // ones that refer to more than one material distribution. Note that in this // case we don't return after setting the function. for (Color c = WHITE; c <= BLACK; ++c) { if (is_KBPsKs(pos, c)) e->scalingFunction[c] = &ScaleKBPsK[c]; else if (is_KQKRPs(pos, c)) e->scalingFunction[c] = &ScaleKQKRPs[c]; } Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board { if (!pos.count<PAWN>(BLACK)) { #ifndef ATOMIC assert(pos.count<PAWN>(WHITE) >= 2); #endif e->scalingFunction[WHITE] = &ScaleKPsK[WHITE]; } else if (!pos.count<PAWN>(WHITE)) { #ifndef ATOMIC assert(pos.count<PAWN>(BLACK) >= 2); #endif e->scalingFunction[BLACK] = &ScaleKPsK[BLACK]; } else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1) { // This is a special case because we set scaling functions // for both colors instead of only one. e->scalingFunction[WHITE] = &ScaleKPKP[WHITE]; e->scalingFunction[BLACK] = &ScaleKPKP[BLACK]; } } // Zero or just one pawn makes it difficult to win, even with a small material // advantage. This catches some trivial draws like KK, KBK and KNK and gives a // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN). if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : npm_b <= BishopValueMg ? 4 : 14); if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg) e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 14); if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN; if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg) e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN; // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE), pos.count<BISHOP>(WHITE) , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) }, { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK), pos.count<BISHOP>(BLACK) , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } }; e->value = int16_t((imbalance<WHITE>(PieceCount) - imbalance<BLACK>(PieceCount)) / 16); return e; }
MaterialInfo* MaterialInfoTable::material_info(const Position& pos) const { Key key = pos.material_key(); MaterialInfo* mi = probe(key); // If mi->key matches the position's material hash key, it means that we // have analysed this material configuration before, and we can simply // return the information we found the last time instead of recomputing it. if (mi->key == key) return mi; // Initialize MaterialInfo entry memset(mi, 0, sizeof(MaterialInfo)); mi->key = key; mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; // Store game phase mi->gamePhase = MaterialInfoTable::game_phase(pos); // Let's look if we have a specialized evaluation function for this // particular material configuration. First we look for a fixed // configuration one, then a generic one if previous search failed. if ((mi->evaluationFunction = funcs->get<Value>(key)) != NULL) return mi; if (is_KXK<WHITE>(pos)) { mi->evaluationFunction = &EvaluateKXK[WHITE]; return mi; } if (is_KXK<BLACK>(pos)) { mi->evaluationFunction = &EvaluateKXK[BLACK]; return mi; } if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN)) { // Minor piece endgame with at least one minor piece per side and // no pawns. Note that the case KmmK is already handled by KXK. assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE))); assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK))); if ( pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2 && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2) { mi->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()]; return mi; } } // OK, we didn't find any special evaluation function for the current // material configuration. Is there a suitable scaling function? // // We face problems when there are several conflicting applicable // scaling functions and we need to decide which one to use. EndgameBase<ScaleFactor>* sf; if ((sf = funcs->get<ScaleFactor>(key)) != NULL) { mi->scalingFunction[sf->color()] = sf; return mi; } // Generic scaling functions that refer to more then one material // distribution. Should be probed after the specialized ones. // Note that these ones don't return after setting the function. if (is_KBPsKs<WHITE>(pos)) mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE]; if (is_KBPsKs<BLACK>(pos)) mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK]; if (is_KQKRPs<WHITE>(pos)) mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE]; else if (is_KQKRPs<BLACK>(pos)) mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK]; Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); if (npm_w + npm_b == VALUE_ZERO) { if (pos.piece_count(BLACK, PAWN) == 0) { assert(pos.piece_count(WHITE, PAWN) >= 2); mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE]; } else if (pos.piece_count(WHITE, PAWN) == 0) { assert(pos.piece_count(BLACK, PAWN) >= 2); mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK]; } else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1) { // This is a special case because we set scaling functions // for both colors instead of only one. mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE]; mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK]; } } // No pawns makes it difficult to win, even with a material advantage if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMidgame) { mi->factor[WHITE] = uint8_t (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(WHITE, BISHOP), 2)]); } if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMidgame) { mi->factor[BLACK] = uint8_t (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(BLACK, BISHOP), 2)]); } // Compute the space weight if (npm_w + npm_b >= 2 * QueenValueMidgame + 4 * RookValueMidgame + 2 * KnightValueMidgame) { int minorPieceCount = pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP) + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP); mi->spaceWeight = minorPieceCount * minorPieceCount; } // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", this allow us to be more flexible // in defining bishop pair bonuses. const int pieceCount[2][8] = { { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT), pos.piece_count(WHITE, BISHOP) , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) }, { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT), pos.piece_count(BLACK, BISHOP) , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } }; mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16); return mi; }