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()
{
}
 
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(epdTest_t const typeOfTest)
{
  if (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 <= 99; 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, typeOfTest);
}
 
/** set EPD position composed of (simplified) FEN and EPD opcodes
 * @param pos is fen-board fen-tomove fen-castling fen-ep [50moves] [move#] [;]cmdsection*
 * cmdsection is bm SanMove; [|] am SanMove; | D[1-99] n;
 *               id ["]identification["]; c[0-9] "comments";
 *               dm n; acs n; noop
 */
void bEpd::setPos(std::string const& pos)
{
  belofte::stringList sFenSgmt = belofte::stringSplit(pos, " ");
  if (sFenSgmt.size() > 4) {
    // 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
    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, "\"");
        }
      }
    }
  }
}
 
//-----------------------------------------------------------------------
 
bEpdPos::bEpdPos(std::string const& s)
{
  setPos(s);
}
 
bEpdPos::bEpdPos(bEpdParamList const& sParams)
{
  std::string s = std::accumulate(sParams.begin(), sParams.end(), std::string(),
          [](std::string result, std::string sElem) {
            return std::move(result) + std::move(sElem) + " ";
          });
  setPos(s);
}
 
bEpdPos::~bEpdPos()
{
}
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
bEpdFile::bEpdFile(std::string const& sFileName)
{
  attachFile(sFileName);
}
 
bEpdFile::bEpdFile(bEpdParamList sParams)
{
  attachFile(sParams[0]);
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
bEpdFile::~bEpdFile()
{
  if (m_sEpdFile.is_open()) m_sEpdFile.close();
}
 
void bEpdFile::attachFile(std::string const& sFileName)
{
  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 line epd file
 * Will calculate a total score and some statistics
 * @param typeOfTest Type for test to be run
 */
bEpdResult bEpdFile::parse(epdTest_t const typeOfTest)
{
  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) {
      // skip
    } else if ((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(typeOfTest);
      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 (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 << std::endl;
 
  return bEpd::tReturn::EPD_OK;
}
 
// eof