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 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";
  }
};
 
#if defined(_DEBUG)
#define DEBUG_sendInfoSearching(b, depth, msg, sc) \
  sendInfoSearching(b, depth, msg, sc)
#define DEBUG_returnInfoSearching(b, depth, msg, sc) \
  sendInfoSearching(b, depth, msg, sc)
#else
#define DEBUG_sendInfoSearching(b, depth, msg, sc)
#define DEBUG_returnInfoSearching(b, depth, msg, sc) \
  sc
#endif
 
//-----------------------------------------------------------------------
 
enum tScoreType : uint8_t {
  SC_UNDEF = 0,
  SC_ALPHA, SC_BETA, SC_CHILD, SC_BEST,
  SC_SIZE
};
 
typedef enum tScoreType scoretype_t;
 
class bSearchScore {
public:
  bSearchScore(bSearchScore const& sc) noexcept;
  explicit bSearchScore(bSearchScore&& sc) noexcept;
  explicit bSearchScore(bScore const& sc) noexcept;
  explicit bSearchScore(bScore const& sc, scoretype_t const& st) noexcept;
  ~bSearchScore();
 
  bSearchScore& operator=(bSearchScore&& sc) noexcept;
  bSearchScore& operator=(bScore const& sc) noexcept;
  bSearchScore& operator=(bScore&& sc) noexcept;
  bSearchScore operator-() const;
 
  bSearchScore& operator=(bSearchScore const&) = delete;
 
  operator std::string() const;
  bScore getScore() const { return m_score; }
  bScore getRealScore() const { return belofte::realScore(m_score); }
 
  friend std::string const operator+(std::string const& lhs, bSearchScore const& sc);
  friend std::string const operator+(bSearchScore const& sc, std::string const& rhs);
  friend bool operator>(bScore const& lhsc, bSearchScore const& rhsc);
  friend bool operator>=(bScore const& lhsc, bSearchScore const& rhsc);
  friend bool operator>(bSearchScore const& lhsc, bScore const& rhsc);
  friend bool operator>(bSearchScore const& lhsc, bSearchScore const& rhsc);
 
private:
  bScore m_score = SCORE_UNDEFINED;
  scoretype_t m_type = tScoreType::SC_UNDEF;
};
 
//-----------------------------------------------------------------------
 
class bSearchAlgorithm : public TimedExecution {
public:
  bSearchAlgorithm(std::string const& n);
  ~bSearchAlgorithm() override;
 
  // no copy or move ctor nor assignment defined
  bSearchAlgorithm(bSearchAlgorithm const&) = delete;
  bSearchAlgorithm(bSearchAlgorithm&&) = delete;
  bSearchAlgorithm& operator=(bSearchAlgorithm const&) = delete;
  bSearchAlgorithm& operator=(bSearchAlgorithm&&) = delete;
 
  operator std::string() const& { return const_cast<std::string const&>(m_name); }
 
  int64_t getNodes() const { return m_nodes; }
  int64_t getNonLeafNodes() const { return m_nonleafnodes; }
 
  void StartSearch(bScore const m);
  void StopSearch();
  void InterruptSearch();
  bBestMoveInfo SearchBestMove(bBoard& b);
 
  bScore sendInfoSearching(bBoard const& b, depth_t const nDepth,
          std::string const& c,
          bScore const sc) const;
 
  bScore RetrieveBoardEvaluation(bBoard& b) const;
 
  depth_t m_maxDepth = 0;
  int64_t m_nodes = 0LL;
  int64_t m_nonleafnodes = 0LL;
  bool m_iterativesearch = false; // access required from bench command
 
protected:
  virtual bScore CalcBestMove(bBoard& b) = 0;
  void CheckIfAbortingSearch() const;
  bScore attenuateScore(bScore const sc) const;
 
  void setLevel(bLevel* l) { m_levelptr = l; }
  bLevel* getLevel() { return m_levelptr; }
 
  void sendInfoCurrMove(bBoard const& b, depth_t const nDepth,
          movenum_t const moveid) const;
  bScore sendInfoScore(bBoard const& b,
          depth_t const nDepth,
          bScore const) const;
  void dumpMoveList(bBoard& b, depth_t const iDepth) const;
 
private:
  bBestMoveInfo SearchBestMoveIterative(bBoard& b);
 
  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;
};
 
//-----------------------------------------------------------------------
 
#endif // defined SEARCH_H
 
// eof