add nelo statistic and annotate WDL result in fastchess output (#226)

gahtan-syarif · web-flow · commit 98a920d23a49 · 2024-04-13T02:12:03.000+02:00
diff --git a/src/matchmaking/elo/elo.cpp b/src/matchmaking/elo/elo.cpp
@@ -9,17 +9,29 @@ namespace fast_chess {
 Elo::Elo(int wins, int losses, int draws) {
     diff_  = getDiff(wins, losses, draws);
     error_ = getError(wins, losses, draws);
+    nelodiff_  = getneloDiff(wins, losses, draws);
+    neloerror_ = getneloError(wins, losses, draws);
 }
 
 Elo::Elo(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) {
     diff_  = getDiff(penta_WW, penta_WD, penta_WL, penta_DD, penta_LD, penta_LL);
     error_ = getError(penta_WW, penta_WD, penta_WL, penta_DD, penta_LD, penta_LL);
+    nelodiff_  = getneloDiff(penta_WW, penta_WD, penta_WL, penta_DD, penta_LD, penta_LL);
+    neloerror_ = getneloError(penta_WW, penta_WD, penta_WL, penta_DD, penta_LD, penta_LL);
 }
 
 double Elo::percToEloDiff(double percentage) noexcept {
     return -400.0 * std::log10(1.0 / percentage - 1.0);
 }
 
+double Elo::percToNeloDiff(double percentage, double stdev) noexcept {
+    return (percentage - 0.5) / (std::sqrt(2) * stdev) * (800 / std::log(10));
+}
+
+double Elo::percToNeloDiffWDL(double percentage, double stdev) noexcept {
+    return (percentage - 0.5) / stdev * (800 / std::log(10));
+}
+
 double Elo::getError(int wins, int losses, int draws) noexcept {
     const double n    = wins + losses + draws;
     const double w    = wins / n;
@@ -37,6 +49,23 @@ double Elo::getError(int wins, int losses, int draws) noexcept {
     return (percToEloDiff(devMax) - percToEloDiff(devMin)) / 2.0;
 }
 
+double Elo::getneloError(int wins, int losses, int draws) noexcept {
+    const double n    = wins + losses + draws;
+    const double w    = wins / n;
+    const double l    = losses / n;
+    const double d    = draws / n;
+    const double perc = w + d / 2.0;
+
+    const double devW  = w * std::pow(1.0 - perc, 2.0);
+    const double devL  = l * std::pow(0.0 - perc, 2.0);
+    const double devD  = d * std::pow(0.5 - perc, 2.0);
+    const double stdev = std::sqrt(devW + devL + devD) / std::sqrt(n);
+
+    const double devMin = perc - 1.959963984540054 * stdev;
+    const double devMax = perc + 1.959963984540054 * stdev;
+    return (percToNeloDiffWDL(devMax, stdev * std::sqrt(n)) - percToNeloDiffWDL(devMin, stdev * std::sqrt(n))) / 2.0;
+}
+
 double Elo::getError(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept {
     const double pairs    = penta_WW + penta_WD + penta_WL + penta_DD + penta_LD + penta_LL;
     const double WW = double(penta_WW) / pairs; 
@@ -58,6 +87,27 @@ double Elo::getError(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int
     return (percToEloDiff(devMax) - percToEloDiff(devMin)) / 2.0;
 }
 
+double Elo::getneloError(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept {
+    const double pairs    = penta_WW + penta_WD + penta_WL + penta_DD + penta_LD + penta_LL;
+    const double WW = double(penta_WW) / pairs; 
+    const double WD = double(penta_WD) / pairs; 
+    const double WL = double(penta_WL) / pairs; 
+    const double DD = double(penta_DD) / pairs;
+    const double LD = double(penta_LD) / pairs;
+    const double LL = double(penta_LL) / pairs;
+    const double a = WW + 0.75 * WD + 0.5 * (WL + DD) + 0.25 * LD;
+    const double WW_dev = WW * std::pow((1 - a), 2);
+    const double WD_dev = WD * std::pow((0.75 - a), 2);
+    const double WLDD_dev = (WL + DD) * std::pow((0.5 - a), 2);
+    const double LD_dev = LD * std::pow((0.25 - a), 2);
+    const double LL_dev = LL * std::pow((0 - a), 2);
+    const double stdev = std::sqrt(WW_dev + WD_dev + WLDD_dev + LD_dev + LL_dev) / std::sqrt(pairs);
+
+    const double devMin = a - 1.959963984540054 * stdev;
+    const double devMax = a + 1.959963984540054 * stdev;
+    return (percToNeloDiff(devMax, stdev * std::sqrt(pairs)) - percToNeloDiff(devMin, stdev * std::sqrt(pairs))) / 2.0;
+}
+
 double Elo::getDiff(int wins, int losses, int draws) noexcept {
     const double n          = wins + losses + draws;
     const double score      = wins + draws / 2.0;
@@ -66,6 +116,20 @@ double Elo::getDiff(int wins, int losses, int draws) noexcept {
     return percToEloDiff(percentage);
 }
 
+double Elo::getneloDiff(int wins, int losses, int draws) noexcept {
+    const double n    = wins + losses + draws;
+    const double w    = wins / n;
+    const double l    = losses / n;
+    const double d    = draws / n;
+    const double perc = w + d / 2.0;
+
+    const double devW  = w * std::pow(1.0 - perc, 2.0);
+    const double devL  = l * std::pow(0.0 - perc, 2.0);
+    const double devD  = d * std::pow(0.5 - perc, 2.0);
+    const double stdev = std::sqrt(devW + devL + devD) / std::sqrt(n);
+    return percToNeloDiffWDL(perc, stdev * std::sqrt(n));
+}
+
 double Elo::getDiff(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept {
     const double pairs          = penta_WW + penta_WD + penta_WL + penta_DD + penta_LD + penta_LL;
     const double WW = double(penta_WW) / pairs; 
@@ -78,6 +142,25 @@ double Elo::getDiff(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int
     return percToEloDiff(percentage);
 }
 
+double Elo::getneloDiff(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept {
+    const double pairs    = penta_WW + penta_WD + penta_WL + penta_DD + penta_LD + penta_LL;
+    const double WW = double(penta_WW) / pairs; 
+    const double WD = double(penta_WD) / pairs; 
+    const double WL = double(penta_WL) / pairs; 
+    const double DD = double(penta_DD) / pairs;
+    const double LD = double(penta_LD) / pairs;
+    const double LL = double(penta_LL) / pairs;
+    const double a = WW + 0.75 * WD + 0.5 * (WL + DD) + 0.25 * LD;
+    const double WW_dev = WW * std::pow((1 - a), 2);
+    const double WD_dev = WD * std::pow((0.75 - a), 2);
+    const double WLDD_dev = (WL + DD) * std::pow((0.5 - a), 2);
+    const double LD_dev = LD * std::pow((0.25 - a), 2);
+    const double LL_dev = LL * std::pow((0 - a), 2);
+    const double stdev = std::sqrt(WW_dev + WD_dev + WLDD_dev + LD_dev + LL_dev) / std::sqrt(pairs);
+
+    return percToNeloDiff(a, stdev * std::sqrt(pairs));
+}
+
 std::string Elo::getElo() const noexcept {
     std::stringstream ss;
 
@@ -87,6 +170,15 @@ std::string Elo::getElo() const noexcept {
     return ss.str();
 }
 
+std::string Elo::getnElo() const noexcept {
+    std::stringstream ss;
+
+    ss << std::fixed << std::setprecision(2) << nelodiff_;
+    ss << " +/- ";
+    ss << std::fixed << std::setprecision(2) << neloerror_;
+    return ss.str();
+}
+
 std::string Elo::getLos(int wins, int losses, int draws) noexcept {
     const double games    = wins + losses + draws;
     const double W = double(wins) / games; 
diff --git a/src/matchmaking/elo/elo.hpp b/src/matchmaking/elo/elo.hpp
@@ -11,16 +11,30 @@ class Elo {
 
     [[nodiscard]] static double percToEloDiff(double percentage) noexcept;
 
+    [[nodiscard]] static double percToNeloDiff(double percentage, double stdev) noexcept;
+
+    [[nodiscard]] static double percToNeloDiffWDL(double percentage, double stdev) noexcept;
+
     [[nodiscard]] static double getDiff(int wins, int losses, int draws) noexcept;
 
     [[nodiscard]] static double getDiff(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept;
 
+    [[nodiscard]] static double getneloDiff(int wins, int losses, int draws) noexcept;
+
+    [[nodiscard]] static double getneloDiff(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept;
+
     [[nodiscard]] static double getError(int wins, int losses, int draws) noexcept;
 
     [[nodiscard]] static double getError(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept;
 
+    [[nodiscard]] static double getneloError(int wins, int losses, int draws) noexcept;
+
+    [[nodiscard]] static double getneloError(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept;
+
     [[nodiscard]] std::string getElo() const noexcept;
 
+    [[nodiscard]] std::string getnElo() const noexcept;
+
     [[nodiscard]] static std::string getLos(int wins, int losses, int draws) noexcept;
 
     [[nodiscard]] static std::string getLos(int penta_WW, int penta_WD, int penta_WL, int penta_DD, int penta_LD, int penta_LL) noexcept;
@@ -36,6 +50,8 @@ class Elo {
    private:
     double diff_;
     double error_;
+    double nelodiff_;
+    double neloerror_;
 };
 
 }  // namespace fast_chess
diff --git a/src/matchmaking/output/output_fastchess.hpp b/src/matchmaking/output/output_fastchess.hpp
@@ -28,11 +28,11 @@ class Fastchess : public IOutput {
            << second                                                     //
            << ": "                                                       //
            << stats.wins                                                 //
-           << " - "                                                      //
+           << "W - "                                                      //
            << stats.losses                                               //
-           << " - "                                                      //
+           << "L - "                                                      //
            << stats.draws                                                //
-           << " ["                                                       //
+           << "D ["                                                       //
            << Elo::getScoreRatio(stats.penta_WW, stats.penta_WD, stats.penta_WL, stats.penta_DD, stats.penta_LD, stats.penta_LL)  //
            << "] "                                                       //
            << current_game_count                                         //
@@ -41,6 +41,9 @@ class Fastchess : public IOutput {
         ss << "Elo difference: "                                        //
            << elo.getElo()                                              //
            << ", "                                                      //
+           << "nElo difference: "                                       //
+           << elo.getnElo()                                             //
+           << ", "                                                      //
            << "LOS: "                                                   //
            << Elo::getLos(stats.penta_WW, stats.penta_WD, stats.penta_WL, stats.penta_DD, stats.penta_LD, stats.penta_LL)        //
            << ", "                                                      //
