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"
 
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();
}
 
//-----------------------------------------------------------------------
 
/**
 * 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=") {
          /// @note 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;
  }
}
 
std::string const bEpd::getTag(std::string const& tag)
{
  if (m_Keys.find(tag) != m_Keys.end()) {
    return m_Keys[tag];
  }
  return "";
}
 
//-----------------------------------------------------------------------
 
/**
 * parse any epd position
 */
bEpdResult bEpd::parse()
{
  if (getTestType() == tEpdTestType::EPD_STS) {
    return parseSTSPosition(bFen(m_Fen));
  }
 
  if (getTestType() == tEpdTestType::EPD_PERF) {
    return parsePerftPosition(bFen(m_Fen));
  }
 
  // 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 parsePerftPosition(bFen(m_Fen));
  }
 
  // this is any other epd test
  return parseEpdPosition(bFen(m_Fen));
}
 
bEpdResult bEpd::parseSTSPosition(bFen const& fen)
{
  bEpdMoveValues moveValues;
  setScore(0);
  if (m_Keys.find("c0") != m_Keys.end()) {
    belofte::stringList c0Parts = belofte::stringSplit(m_Keys["c0"], ":");
    // drop part before : character
    if (c0Parts.size() > 1) c0Parts.erase(c0Parts.begin());
    if (!c0Parts.empty()) {
      // convert c0 tag into keypairs
      // e.g. f5=10, Be5+=2, Bf2=3, Bg4=2
      belofte::stringList sC0Segment = belofte::stringSplit(c0Parts.front(), ",");
      for (auto it = sC0Segment.begin(); it != sC0Segment.end(); ++it) {
        // remove leading - trailing space(s) on m_Keys
        /// @todo protect against malformed STS containing no = sign
        std::pair<std::string, std::string> sMoveVal = belofte::decompose(*it, "=");
        moveValues[belofte::alltrim(sMoveVal.first)] = atoi(belofte::alltrim(sMoveVal.second).c_str());
      }
    }
  } else if (m_Keys.find("bm") == m_Keys.end()) {
    // neither bm or c0 is present
    return bEpd::tReturn::EPD_ERROR;
  }
 
  if (m_Keys.find("bm") != m_Keys.end()) {
    // find all bm and add them to list if not yet present in list
    belofte::stringList const sMoves = belofte::stringSplit(m_Keys["bm"], " ");
    for (auto it = sMoves.begin(); it != sMoves.end(); ++it) {
      // remove leading - trailing space(s) on moves
      std::string sMove = belofte::alltrim(*it);
      if (moveValues.find(sMove) == moveValues.end()) {
        // not present yet
        moveValues.insert(std::make_pair(sMove,10));
      }
    }
  }
 
  bMove m(Game()->getEpdMoveInPosition(fen));
  bBoard const& b = Game()->getCurrentPosition();
  bPgnMove pgnmove(b, m.getBMoveT());
  int score = translateSTSResult(pgnmove, moveValues);
  setScore(score);
  return bEpd::tReturn::STS_OK;
}
 
/**
 * do actual epd position test
 */
bEpdResult bEpd::parseEpdPosition(bFen const& fen)
{
  bMove m(Game()->getEpdMoveInPosition(fen));
  bBoard const& currentPosition = Game()->getCurrentPosition();
  bPgnMove pgnmove(currentPosition, m.getBMoveT());
  return translateEpdResult(pgnmove);
}
 
/**
 * check move found against epd line m_Keys, change level
 * before starting search
 * am avoid-moves
 * bm best-moves
 * acs # set search seconds
 * acn # set search nodes
 * dm # set direct mate depth
 */
bEpdResult bEpd::translateEpdResult(bPgnMove const& m)
{
  if (m_Keys.find("bm") != m_Keys.end()) {
    belofte::stringList const sMoves = belofte::stringSplit(m_Keys["bm"], " ");
    if (std::any_of(sMoves.begin(), sMoves.end(),
            [m](std::string const& sm)
            { return m == sm; })) {
      return bEpd::tReturn::BM_OK;
    }
  } else if (m_Keys.find("am") != m_Keys.end()) {
    // am and bm are exclusive
    belofte::stringList const sMoves = belofte::stringSplit(m_Keys["am"], " ");
    if (std::none_of(sMoves.begin(), sMoves.end(),
            [m](std::string const& sm)
            { return m == sm; })) {
      return bEpd::tReturn::AM_OK;
    }
  } /// @todo implement other opcodes such as mate search
 
  App().bout << "found : " << m << " - ";
  return bEpd::tReturn::NOT_RESOLVED;
}
 
int bEpd::translateSTSResult(bPgnMove const& m, bEpdMoveValues& moveValues)
{
  std::string ms = m;
  if (moveValues.find(ms) != moveValues.end()) {
    return moveValues[ms];
  }
  return 0;
}
 
/**
 * check perft result for different depths
 * D[1-99] # perft test - nodes
 */
bEpdResult bEpd::parsePerftPosition(bFen const& fen)
{
  bEpdResult result = bEpd::tReturn::PERFT_OK;
  Game()->newGame();
  Game()->setFEN(fen);
 
  // Parse all D1-D99 m_Keys as perft tests
  for (int i = 1; i <= EPD_PERFTMAXDEPTH; i++) {
    std::string sOp = "D" + belofte::to_string(i);
    if (m_Keys.find(sOp) != m_Keys.end()) {
      std::string sPerftResult = belofte::alltrim(m_Keys[sOp]);
      int64_t nodes = Game()->DoPerftCommand(static_cast<depth_t>(i));
      if (sPerftResult != belofte::to_string(nodes)) {
        App().bout << "Not resolved, found nodes : " << belofte::to_string(nodes) << " - "
          << std::string(*this);
        result = bEpd::tReturn::PERFT_MISS;
        break;
      }
    }
  }
 
  return result;
}
 
//-----------------------------------------------------------------------
 
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);
}
 
//-----------------------------------------------------------------------
 
#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) == "#")) {
      /// @todo consider other prefixes to be skipped (e.g. //, %)
      // skip
    } else {
      setPos(line);
      bEpdResult result = bEpd::parse();
      std::string sID = getTag("id");
      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::STS_OK) {
        // we get actual score instead of maximum score
        int sc = getScore();
        nGoods += sc;
        /// @todo consider to use verbosity level to dictate output
        App().bout << "score : " << std::setw(2) << sc
          << " Total : " << std::setw(4) << nGoods;
        if (!sID.empty()) App().bout << " (" << sID << ")";
        App().bout.endl();
      } else if (result >= bEpd::tReturn::BM_OK) {
        // AM_OK, MATE_OK, ... are equal to maximum score
        // so we just return maximum score
        nGoods += bEpd::tReturn::BM_OK;
      } else if (result == bEpd::tReturn::PERFT_MISS) {
        // no logging, we already reported before
      } else if (result == bEpd::tReturn::NOT_RESOLVED) {
        /// @todo consider to use verbosity level to dictate output
        App().bout << "Not resolved";
        if (!sID.empty()) App().bout << " (" << sID << ")";
        App().bout.endl();
        // skip
      } else if (result == bEpd::tReturn::NO_MOVE_FOUND) {
        App().bout << "No move found : " << std::string(*this);
      }
      // total is a multiple of BM_OK (10)
      nTotal += bEpd::tReturn::BM_OK;
    }
  }
  m_sEpdFile.close();
 
  if (getTestType() == tEpdTestType::EPD_STS) {
    // score of STS test is relative to total value
    App().bout << "Result " << std::setprecision(3) << std::defaultfloat
      << static_cast<float>(nGoods)/static_cast<float>(bEpd::tReturn::BM_OK)
      << "/" << static_cast<float>(nTotal)/static_cast<float>(bEpd::tReturn::BM_OK);
  } else {
    App().bout << "Result " << nGoods / bEpd::tReturn::BM_OK
            << "/" << nTotal / bEpd::tReturn::BM_OK;
  }
  if (nTotal > 0) {
    App().bout << " = " << std::setprecision(4) << std::defaultfloat
      << static_cast<float>(nGoods * 100.0) / static_cast<float>(nTotal) << "%\n";
  }
  App().bout.endl();
 
  return bEpd::tReturn::EPD_OK;
}
 
// eof