tree.h

/*
* Copyright (C) 1999 Shane Hudson
* Copyright (C) 2015-2020 Fulvio Benini
 
* This file is part of Scid (Shane's Chess Information Database).
*
* Scid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation.
*
* Scid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scid.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include "scid/core/fullmove.h"
#include "scid/core/game_result.h"
#include "scid/database/common.h"
#include "scid/database/game_id.h"
 
namespace scid::database {
 
struct TreeNode {
    unsigned long long eloWhiteSum = 0;   // Sum of white Elos.
    unsigned long long eloBlackSum = 0;   // Sum of bLack Elos.
    unsigned long long yearSum = 0;       // Sum of years.
    gamenumT freq[scid::core::NUM_RESULT_TYPES] = {}; // freq[0] is the total count.
    gamenumT eloCount = 0;                // Count of games with an Elo.
    gamenumT yearCount = 0;               // Count of games with year != 0.
    scid::core::FullMove move;
 
public:
    explicit TreeNode(scid::core::FullMove m) : move(m) {}
 
    void add(scid::core::resultT result, int eloW, int eloB, unsigned year) {
        static_assert(scid::core::RESULT_None == 0);
        freq[0]++; // total count of games
        if (result != scid::core::RESULT_None) {
            freq[result]++;
        }
        if (eloW > 0 && eloB > 0) {
            ++eloCount;
            eloWhiteSum += eloW;
            eloBlackSum += eloB;
        }
        if (year > 0) {
            yearSum += year;
            ++yearCount;
        }
    }
 
    int score() const {
        auto n = freq[scid::core::RESULT_White] + freq[scid::core::RESULT_Draw] + freq[scid::core::RESULT_Black];
        auto res = 1000ull * freq[scid::core::RESULT_White] + 500ull * freq[scid::core::RESULT_Draw];
        return n ? static_cast<int>(res / n) : 500;
    }
 
    double eloPerformance() const {
        if (eloCount == 0)
            return 0;
 
        int score = (this->score() + 5) / 10;
        auto eloOpp = eloBlackSum;
        if (move.getColor() != scid::core::WHITE) {
            score = 100 - score;
            eloOpp = eloWhiteSum;
        }
        return 1.0 * eloOpp / eloCount + FIDE_ratingTable[score];
    }
 
    double avgElo() const {
        if (eloCount == 0)
            return 0;
 
        auto elo = (move.getColor() == scid::core::WHITE) ? eloWhiteSum : eloBlackSum;
        return 1.0 * elo / eloCount;
    }
 
    double avgYear() const { return yearCount ? 1.0 * yearSum / yearCount : 0; }
 
    double percDraws() const {
        return freq[0] ? 100.0 * freq[scid::core::RESULT_Draw] / freq[0] : 0;
    }
 
    static auto cmp_ngames_desc() {
        return
            [](auto const& a, auto const& b) { return a.freq[0] > b.freq[0]; };
    }
 
private:
    // FIDE table 8.1a of conversion from fractional score (from 0 to 1 with
    // 0.01 increments) into rating differences.
    static constexpr short FIDE_ratingTable[] = {
        -800, -677, -589, -538, -501, -470, -444, -422, -401, -383, -366, -351,
        -336, -322, -309, -296, -284, -273, -262, -251, -240, -230, -220, -211,
        -202, -193, -184, -175, -166, -158, -149, -141, -133, -125, -117, -110,
        -102, -95,  -87,  -80,  -72,  -65,  -57,  -50,  -43,  -36,  -29,  -21,
        -14,  -7,   0,    7,    14,   21,   29,   36,   43,   50,   57,   65,
        72,   80,   87,   95,   102,  110,  117,  125,  133,  141,  149,  158,
        166,  175,  184,  193,  202,  211,  220,  230,  240,  251,  262,  273,
        284,  296,  309,  322,  336,  351,  366,  383,  401,  422,  444,  470,
        501,  538,  589,  677,  800};
};
 
} // namespace scid::database