epd_testsuite.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: epd_testsuite.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
bEpd::bEpd(epdTest_t const typeOfTest)
  : m_typeOfTest{typeOfTest}
{
}
 
bEpd::~bEpd()
{
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
bEpd::operator std::string() const
{
  std::stringstream ss;
  ss << m_Fen << " => ";
  for (const auto &m : m_Keys)
    ss << "[" << m.first << "] = " << m.second << "; ";
  ss << "\n";
  return ss.str();
}
 
bEpdResult bEpd::parse()
{
  if (m_typeOfTest == tEpdTestType::EPD_PERF) {
    return Game()->evalPerftResult(bFen(m_Fen), m_Keys);
  }
 
  // check if any D[1-99] is in list
  bool bPerft = false;
  for (int i = 1; i <= EPD_PERFTMAXDEPTH; i++) {
    std::string sOp = "D" + belofte::to_string(i);
    if (m_Keys.find(sOp) != m_Keys.end()) { bPerft = true; break; }
  }
  if (bPerft) {
    return Game()->evalPerftResult(bFen(m_Fen), m_Keys);
  }
 
  return Game()->evalEpdPosition(bFen(m_Fen), m_Keys);
}
 
/** EPD pos is fen-board fen-tomove fen-castling fen-ep [50moves] [move#] cmdsection*
 * cmdsection is bm SanMove! | am SanMove! | id=["]identification["]
 * id ["]identification["] | D[1-99] n | n[,n[,n]...]
 */
void bEpd::setPos(std::string const& s)
{
  belofte::stringList sFenSgmt = belofte::stringSplit(s, " ");
  if (sFenSgmt.size() >= 4) {
    // decompose perft elements, splitting -,20,400 into list["-","20","400"]
    belofte::stringList sPerftCommaElem = belofte::stringSplit(sFenSgmt[3], ",");
    if (sPerftCommaElem.size() > 1) {
      sFenSgmt[3] = sPerftCommaElem[0];
    }
    // compose FEN part
    m_Fen = sFenSgmt[0] + " " + sFenSgmt[1] + " "
            + sFenSgmt[2] + " " + sFenSgmt[3];
    sFenSgmt.erase(sFenSgmt.begin(), sFenSgmt.begin() + 4);
 
    // 50 move counter
    if (belofte::is_number(sFenSgmt[0])) {
      m_Fen += " " + sFenSgmt[0];
      sFenSgmt.erase(sFenSgmt.begin());
    } else {
      m_Fen += " 0";
    }
 
    // move number
    if (belofte::is_number(sFenSgmt[0])) {
      m_Fen += " " + sFenSgmt[0];
      sFenSgmt.erase(sFenSgmt.begin());
    } else {
      m_Fen += " 1";
    }
 
    // compose command part based on remainder of line
    if (sPerftCommaElem.size() > 1) {
      // convert list["-","20","400"] to D1 20 ;D2 400 ;D3 8902 ;
      std::stringstream sPerftSection;
      for (unsigned long i = 1; (i < EPD_PERFTMAXDEPTH) && (sPerftCommaElem.size() > i); ++i) {
        sPerftSection << "D" << belofte::to_string(static_cast<int32_t>(i)) << " "
                      << sPerftCommaElem[i] << ";";
      }
      sFenSgmt.push_back(sPerftSection.str());
    }
 
    // make sure FEN extension starts with ;
    std::string sCmd = ";" + std::accumulate(sFenSgmt.begin(), sFenSgmt.end(), std::string(),
            [](std::string result, std::string sElem) {
              return std::move(result) + std::move(sElem) + " ";
            });
    belofte::stringList sCmdSgmt = belofte::stringSplit(sCmd, ";");
 
    // remove leading - trailing space(s) on opcodes
    for (auto it = sCmdSgmt.begin(); it != sCmdSgmt.end(); ++it) {
      *it = belofte::alltrim(*it);
    }
 
    m_Keys.clear();
    // split each command in between opcode and info
    // remove quotes from info
    for (const auto &sElem : sCmdSgmt) {
      if (sElem.length() > 0) {
        // TODO: do only consider opcode starting with letter
        if (sElem.substr(0,3) == "id=") {
          /// @deprecated backwards compatibility with belofte 0.9.x, which has testfiles where
          /// id is followed by = sign instead of space
          std::pair<std::string, std::string> sCmdOpcode = belofte::decompose(sElem, "=");
          m_Keys[sCmdOpcode.first] = belofte::alltrim(sCmdOpcode.second, "\"");
        } else {
          // any other command followed by space, e.g. bm | am | id | D[1-99] |
          //                                           c[0-9] | acs | dm
          std::pair<std::string, std::string> sCmdOpcode = belofte::decompose(sElem, " ");
          m_Keys[sCmdOpcode.first] = belofte::alltrim(sCmdOpcode.second, "\"");
        }
      }
    }
 
    m_valid = true;
  }
}
 
//-----------------------------------------------------------------------
 
bEpdPos::bEpdPos(std::string const& s, epdTest_t const typeOfTest)
  : bEpd(typeOfTest)
{
  setPos(s);
}
 
bEpdPos::bEpdPos(bEpdParamList const& sParams, epdTest_t const typeOfTest)
  : bEpd(typeOfTest)
{
  std::string s;
  for (const auto &sElem : sParams) s += sElem + " ";
  setPos(s);
}
 
bEpdPos::~bEpdPos()
{
}
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
bEpdFile::bEpdFile(std::string const& sFileName, epdTest_t const typeOfTest)
  : bEpd(typeOfTest)
{
  handleFile(sFileName);
}
 
bEpdFile::bEpdFile(bEpdParamList const& sParams, epdTest_t const typeOfTest)
  : bEpd(typeOfTest)
{
  if (!sParams.empty()) {
    handleFile(sParams[0]);
  }
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
bEpdFile::~bEpdFile()
{
  if (m_sEpdFile.is_open()) m_sEpdFile.close();
}
 
void bEpdFile::handleFile(std::string const& sFileName)
{
  if (sFileName.empty()) {
    AppEI()->sendError("Filename missing", sFileName);
  } else {
    m_sEpdFile.open(sFileName.c_str(), std::ios::in );
    if (!m_sEpdFile.is_open()) {
      AppEI()->sendError("Could not open file", sFileName);
    } else {
      AppEI()->sendDebug(1, "Reading " + sFileName);
    }
  }
}
 
/** Main epd parser for multiple lines of epd file
 * Will calculate a total score and some statistics
 */
bEpdResult bEpdFile::parse()
{
  int nGoods = 0;
  int nTotal = 0;
  if (!m_sEpdFile.is_open()) return bEpd::tReturn::EPD_ERROR;
  std::string line;
  while(getline(m_sEpdFile,line)) {
    if ((line.length() < 6)
        || (line.substr(0,1) == ";")
        || (line.substr(0,1) == "#")) {
      /// @remark consider other prefixes to be skipped (e.g. //, %)
      // skip
    } else {
      setPos(line);
      bEpdResult result = bEpd::parse();
      if (result == bEpd::tReturn::EPD_ERROR) {
        App().bout << "Error : " << std::string(*this);
        return bEpd::tReturn::EPD_ERROR;
      } else if (result >= bEpd::tReturn::PERFT_OK) {
        App().bout << "Perft OK : " << std::string(*this);
        nGoods += bEpd::tReturn::BM_OK;
      } else if (result == bEpd::tReturn::EPD_OK) {
        continue; // skip
      } else if (result > bEpd::tReturn::BM_OK) {
        // AM_OK, MATE_OK, ... are equal to maximum score
        nGoods += bEpd::tReturn::BM_OK;
      } else if (result > bEpd::tReturn::EPD_OK) {
        // STS can return fraction of total score
        nGoods += result;
      } else if (result == bEpd::tReturn::NOT_RESOLVED) {
        App().bout << "Not resolved : " << std::string(*this);
      } else if (result == bEpd::tReturn::NO_MOVE_FOUND) {
        App().bout << "No move found : " << std::string(*this);
      }
      nTotal += bEpd::tReturn::BM_OK;
    }
  }
  m_sEpdFile.close();
 
  if (m_typeOfTest == tEpdTestType::EPD_STS) {
    // score of STS test is relative to total value
    App().bout << "Result " << nGoods << "/" << nTotal;
  } else {
    App().bout << "Result " << nGoods / bEpd::tReturn::BM_OK
            << "/" << nTotal / bEpd::tReturn::BM_OK;
  }
  if (nTotal > 0) App().bout << " = " << (nGoods * 100) / nTotal << "%\n";
  App().bout.endl();
 
  return bEpd::tReturn::EPD_OK;
}
 
// eof