util.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: util.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
/** implementation of timing functions */
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
TimedExecution::TimedExecution()
{
  // make sure clockstart is initialized
  ClockStart();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
void TimedExecution::ClockStart()
{
#if defined(CHRONO_MISSING)
  gettimeofday(&execution_start, NULL);
#else
  execution_start = std::chrono::high_resolution_clock::now();
#endif
  m_isEnded = false;
}
 
void TimedExecution::ClockEnd()
{
#if defined(CHRONO_MISSING)
  gettimeofday(&execution_end, NULL);
#else
  execution_end = std::chrono::high_resolution_clock::now();
#endif
  m_isEnded = true; /// @todo TOCHECK: for multi-threaded, make sure there is no race condition
}
 
std::string TimedExecution::getDuration() const
{
  std::string duration;
  if (getDurationMicroSec() < 99000LL)
#if defined(BELOFTE_NOUNICODE)
    duration = belofte::to_string(static_cast<int64_t>(getDurationMicroSec())) + " microsec";
#else
    duration = belofte::to_string(static_cast<int64_t>(getDurationMicroSec())) + " μs";
#endif
  else
    duration = belofte::prettyTime(getDurationMilliSec());
  return duration;
}
 
long long TimedExecution::getDurationMicroSec() const
{
  if (m_isEnded) {
#if defined(CHRONO_MISSING)
    return (execution_end.tv_sec * 1000000LL + execution_end.tv_usec) -
            (execution_start.tv_sec * 1000000LL + execution_start.tv_usec);
#else
    return std::chrono::duration_cast<std::chrono::microseconds>(execution_end - execution_start).count();
#endif
  }
#if defined(CHRONO_MISSING)
  struct timeval now_end;
  gettimeofday(&now_end, NULL);
  return (now_end.tv_sec * 1000000LL + now_end.tv_usec) -
          (execution_start.tv_sec * 1000000LL + execution_start.tv_usec);
#else
  std::chrono::high_resolution_clock::time_point now_end;
  now_end = std::chrono::high_resolution_clock::now();
  return std::chrono::duration_cast<std::chrono::microseconds>(now_end - execution_start).count();
#endif
}
 
long long TimedExecution::getDurationMilliSec() const
{
  if (m_isEnded) {
#if defined(CHRONO_MISSING)
    return (execution_end.tv_sec * 1000LL + execution_end.tv_usec / 1000LL) -
            (execution_start.tv_sec * 1000LL + execution_start.tv_usec / 1000LL);
#else
    return std::chrono::duration_cast<std::chrono::milliseconds>(execution_end - execution_start).count();
#endif
  }
#if defined(CHRONO_MISSING)
  struct timeval now_end;
  gettimeofday(&now_end, NULL);
  return (now_end.tv_sec * 1000LL + now_end.tv_usec / 1000LL) -
          (execution_start.tv_sec * 1000LL + execution_start.tv_usec / 1000LL);
#else
  std::chrono::high_resolution_clock::time_point now_end;
  now_end = std::chrono::high_resolution_clock::now();
  return std::chrono::duration_cast<std::chrono::milliseconds>(now_end - execution_start).count();
#endif
}
 
long long TimedExecution::getDurationSec() const
{
  if (m_isEnded) {
#if defined(CHRONO_MISSING)
    return (execution_end.tv_sec + execution_end.tv_usec / 1000000LL) -
            (execution_start.tv_sec + execution_start.tv_usec / 1000000LL);
#else
    return std::chrono::duration_cast<std::chrono::seconds>(execution_end - execution_start).count();
#endif
  }
#if defined(CHRONO_MISSING)
  struct timeval now_end;
  gettimeofday(&now_end, NULL);
  return (now_end.tv_sec + now_end.tv_usec / 1000000LL) -
          (execution_start.tv_sec + execution_start.tv_usec / 1000000LL);
#else
  std::chrono::high_resolution_clock::time_point now_end;
  now_end = std::chrono::high_resolution_clock::now();
  return std::chrono::duration_cast<std::chrono::seconds>(now_end - execution_start).count();
#endif
}
 
// --------------------------------------------------------------------
// utility functions
 
/** Split delimited long string into a vector
 */
belofte::stringList const belofte::stringSplit(std::string src, std::string const& delim)
{
  stringList v;
  size_t delimPos = src.find(delim);
  while (delimPos != std::string::npos) {
    v.emplace_back(src.substr(0, delimPos));
    src = src.substr(delimPos + delim.length());
    delimPos = src.find(delim);
  }
  std::string s = alltrim(src, delim);
  if (s != "") v.emplace_back(s);
  return v;
}
 
/** Split delimited long string into a pair based on delimiter
 *  e.g. parameter1=x y z, "=" => parameter1, x y z
 *      1) the chapter, " " => 1), the chapter
 */
std::pair<std::string, std::string> belofte::decompose(std::string const& src,
        std::string const& delim)
{
  std::string first;
  std::string second;
  size_t delimPos = src.find(delim);
  if (delimPos != std::string::npos) {
    first = src.substr(0, delimPos);
    second = src.substr(delimPos + delim.length());
  } else {
    first = src;
  }
  return std::make_pair(first, second);
}
 
/** std::to_string not compatible on Mac OS (Apple LLVM version 5.0)
 *  provide generic utility function
 */
std::string belofte::to_string(int32_t value)
{
  std::ostringstream ss;
  ss << value;
  return ss.str();
}
 
std::string belofte::to_string(int64_t value)
{
  std::ostringstream ss;
  ss << value;
  return ss.str();
}
 
/** trim left and right spaces or delim from string
 */
std::string belofte::alltrim(std::string s, std::string const& delim)
{
  if (!s.empty()) {
    while (s.find(delim) == 0) s.erase(0, 1);
    size_t len = s.size();
    while (!s.empty() && (s.rfind(delim) == --len)) s.erase(len, len + 1);
  }
  return s;
}
 
bool belofte::is_number(std::string const& s)
{
  return !s.empty() && std::find_if(s.begin(), s.end(),
          [](unsigned char c) { return !std::isdigit(c); }) == s.end();
}
 
/** return random in between 0 and nCeil - 1
 */
int belofte::getRandomInt(int const nCeil)
{
#if defined(BELOFTE_NORANDOM)
  return 0;
#else
  if (App().getConfig("random", 0)) {
    return std::rand() % nCeil;
  } else {
    return 0;
  }
#endif
}
 
int belofte::getRandomRange(int const nStart, int const nMax)
{
#if defined(BELOFTE_NORANDOM)
  return (nStart + nMax) / 2;
#else
  if (App().getConfig("random", 0)) {
    return nStart + std::rand() % (nMax + 1 - nStart);
  } else {
    return (nStart + nMax) / 2;
  }
#endif
}
 
/** convert executable name into name.rc, possibly dropping .exe suffix
 */
std::string belofte::getRCname(std::string const& basename)
{
  std::string rcname(basename);
 
  std::size_t found = rcname.rfind(std::string(".exe"));
  if (found != std::string::npos)
    rcname = rcname.erase(found, std::string::npos);
  return rcname + ".rc";
}
 
/**
 * find position in which param has been found
 * @param param vector of strings
 * @param find string to find
 * @return -1 in case of nothing found
 */
int belofte::positionParamIndex(stringList const& param,
        std::string const& find)
{
  for (unsigned int i = 0; i < param.size(); i++) {
    if (param[i] == find) return static_cast<int> (i);
  }
  return -1;
}
 
int belofte::positionParamValue(stringList const& param,
        std::string const& find, unsigned long const nOffSet)
{
  for (unsigned int i = 0; i < param.size(); i++) {
    if (param[i] == find) {
      if (i < param.size() + nOffSet) return atoi(param[i + nOffSet].c_str());
    }
  }
  return -1;
}
 
std::string belofte::currentDate()
{
  time_t now = time(nullptr);
  struct tm tstruct;
  char buf[40];
  tstruct = *localtime(&now);
  strftime(buf, sizeof (buf), "%Y.%m.%d", &tstruct);
  return buf;
}
 
std::string belofte::scoreAsStr(long const sc)
{
#if defined(BELOFTE_NOUNICODE)
  if (sc == SCORE_INFINITE) return "INF.";
  if (sc == -SCORE_INFINITE) return "-INF.";
  if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) return "UNDEF.";
  if (sc == SCORE_THEORETIC_DRAW) return "1/2-1/2";
#else
  if (sc == SCORE_INFINITE) return "∞";
  if (sc == -SCORE_INFINITE) return "-∞";
  if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) return "∅";
  if (sc == SCORE_THEORETIC_DRAW) return "½-½";
#endif
  if (sc == SCORE_PRACTICAL_DRAW) return belofte::to_string(static_cast<int32_t>(sc));
  if (sc > SCORE_WINNING) {
    // mate or mate in n moves
    if (sc >= SCORE_MATE - SCORE_CONVERGE_BYDEPTH) return "mate";
    else return "M-" + belofte::to_string(static_cast<int32_t>((SCORE_MATE - sc + 1) / 2));
  }
  if (sc < -SCORE_WINNING) {
    // mate or mate in n moves
    if (sc <= -SCORE_MATE + SCORE_CONVERGE_BYDEPTH) return "mate";
    else return "-M" + belofte::to_string(static_cast<int32_t>(-(SCORE_MATE + sc) / 2));
  }
  return belofte::to_string(static_cast<int32_t>(sc));
}
 
std::string belofte::prettyTime(long const nTime)
{
  long nSeconds = nTime / 1000;
  int ms = nTime % 1000;
  std::stringstream sTime;
  if (nSeconds < 60) {
    sTime << belofte::to_string(static_cast<int32_t>(nSeconds));
  } else {
    if (nSeconds >= 86400) {
      sTime << belofte::to_string(static_cast<int32_t>(nSeconds / 86400)) << "d ";
      nSeconds %= 86400;
    }
    if (nSeconds >= 3600) {
      sTime << belofte::to_string(static_cast<int32_t>(nSeconds / 3600)) << ":";
      nSeconds %= 3600;
    } else if (nTime > 86400000) {
      sTime << "00:";
    }
    if (nSeconds >= 60) {
      sTime << std::setw(2) << std::setfill('0')
              << belofte::to_string(static_cast<int32_t>(nSeconds / 60)) << ":";
      nSeconds %= 60;
    } else {
      sTime << "00:";
    }
    sTime << std::setw(2) << std::setfill('0') << belofte::to_string(static_cast<int32_t>(nSeconds));
  }
  if (ms) {
    sTime << "." << std::setw(3) << std::setfill('0')
            << belofte::to_string(static_cast<int32_t>(ms));
  }
  return sTime.str();
}
 
// eof