search.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: search.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(SEARCH_H)
#define SEARCH_H
 
class gameEndException : public std::exception
{
  const char * what () const noexcept override
    { return "Game ended"; }
};
 
class noMoveFoundException : public std::exception
{
  const char * what () const noexcept override
    { return "Nothing found"; }
};
 
class searchAbortedException : public std::exception
{
  const char * what () const noexcept override
    { return "Aborting search"; }
};
 
class treeLogicException : public std::exception
{
public:
  explicit treeLogicException()
    : m_msg("tree logic exception, should not occur")
    {}
  explicit treeLogicException(std::string const& msg)
    : m_msg(msg)
    {}
 
  const char* what() const noexcept override {
    return m_msg.c_str();
  }
 
private:
  std::string m_msg;
};
 
//-----------------------------------------------------------------------
 
#if defined(_DEBUG)
#define DEBUG_sendInfoSearching(b, depth, msg, sc) sendInfoSearching(b, depth, msg, sc)
#define DEBUG_sendInfoSearchingNS(b, depth, msg) sendInfoSearching(b, depth, msg)
#else
#define DEBUG_sendInfoSearching(b, depth, msg, sc)
#define DEBUG_sendInfoSearchingNS(b, depth, msg)
#endif
 
#if defined(BELOFTE_NOUNICODE)
 
#define ALPHA "alpha"
#define BETA "beta"
#define ALPHABETA "alpha-beta"
#define BE_INF "INF."
#define BE_DRAW "1/2-1/2"
 
#if defined(_DEBUG)
#define BE_UNDEFINED "UNDEF."
#define GTOREQUAL " >= "
#endif
 
#else
 
#define ALPHA "𝛼"
#define BETA "𝛽"
#define ALPHABETA "𝛼𝛽"
#define BE_INF "∞"
#define BE_DRAW "½-½"
 
#if defined(_DEBUG)
#define BE_UNDEFINED "*"
#define GTOREQUAL " ≥ "
#endif
 
#endif
 
#if !defined(_DEBUG)
#define BE_UNDEFINED ""
#endif
 
//-----------------------------------------------------------------------
 
class bSearchAlgorithm : public TimedExecution {
public:
  explicit bSearchAlgorithm(std::string const& s)
    : m_aborting{false}
    , m_name{s}
    , m_levelptr{nullptr}
    , m_appei{nullptr}
    , m_evalptr{nullptr}
    {}
  ~bSearchAlgorithm() override
    { m_levelptr = nullptr; }
 
  // no copy or move ctor nor assignment defined
  bSearchAlgorithm(bSearchAlgorithm const&) = delete;
  bSearchAlgorithm(bSearchAlgorithm&&) = delete;
  bSearchAlgorithm& operator=(bSearchAlgorithm const&) = delete;
  bSearchAlgorithm& operator=(bSearchAlgorithm&&) = delete;
 
  constexpr int64_t getNodes() const
    { return m_leafnodes; }
  constexpr int64_t getNonLeafNodes()
    const { return m_nonleafnodes; }
 
  void StartSearch(bScore const sc);
  void StopSearch();
  inline void InterruptSearch()
    { m_aborting = true; }
 
  void SearchBestMove(bBoard& b, bMoveList& ml);
 
  void sendInfoSearching(bBoard const& b, depth_t const nDepth,
          std::string const& comment) const;
  bScore sendInfoSearching(bBoard const& b, depth_t const nDepth,
          std::string const& comment,
          bScore const sc) const;
 
  bScore RetrieveBoardEvaluation(bBoard& b,
          gameResult_t const gr, bool const bRecalcFirst) const;
  bScore RetrieveBoardEvaluationForWhite(bBoard& b,
          gameResult_t const gr, bool const bRecalcFirst) const;
 
  constexpr bool isNoBench() const
    { return m_noBench; }
  constexpr bool isBench() const
    { return !m_noBench; }
  inline void setBench()
    { m_noBench = false; }
  inline void clearBench()
    { m_noBench = true; }
 
  operator std::string() const&
    { return const_cast<std::string const&>(m_name); }
 
  int64_t m_leafnodes = 0LL;
  int64_t m_nonleafnodes = 0LL;
  bool m_iterativesearch = false; // access required from bench command
 
protected:
  virtual bScore CalcBestMove(bBoard& b, bMoveList& ml) = 0;
  void CheckIfAbortingSearch() const;
 
  inline void adjustMaxSearchedDepth(depth_t const nDepth)
    { if (nDepth > m_maxDepth) m_maxDepth = nDepth; }
  constexpr depth_t getMaxSearchedDepth() const
    { return m_maxDepth; }
  inline void initMaxSearchedDepth()
    { m_maxDepth = 0; }
 
  inline void setLevel(bLevel* l)
    { m_levelptr = l; }
  inline bLevel* getLevel()
    { return m_levelptr; }
 
  void sendInfoCurrMove(bBoard const& b,
          depth_t const nCurDepth,
          bMove const& m,
          movenum_t const moveid) const;
 
private:
  void SearchBestMoveIterative(bBoard& b, bMoveList& ml);
  void dumpMoveList(bMoveList const& ml, depth_t const iDepth) const;
 
  depth_t m_maxDepth = 0;
  bool m_noBench = true; // set to false during bench or perft execution
  int m_postlevel = 0;
  bScore m_minimizing = 1; // set to -1 if searching started for black
  std::atomic<bool> m_aborting;
  std::string m_name;
  bLevel* m_levelptr;
  engineInterface* m_appei;
  bPositionEvaluation* m_evalptr;
};
 
//-----------------------------------------------------------------------
 
#endif // defined SEARCH_H
 
// eof