searchscore.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: searchscore.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(SEARCHSCORE_H)
#define SEARCHSCORE_H
 
//-----------------------------------------------------------------------
 
enum tScoreType : uint8_t {
  SC_UNDEF = 0,
  SC_ALPHA, SC_BETA,
  SC_SIZE
};
 
typedef enum tScoreType scoretype_t;
 
//-----------------------------------------------------------------------
 
class bSearchScore {
public:
  bSearchScore(bSearchScore& sc)
    : u_scoreInfo{sc.u_scoreInfo}
    {}
  bSearchScore(bSearchScore const& sc)
    : u_scoreInfo{sc.u_scoreInfo}
    {}
  bSearchScore(bSearchScore&& sc)
    : u_scoreInfo{std::move(sc.u_scoreInfo)}
    {}
  explicit bSearchScore(bScore const& score)
    : m_score{score}
    {}
  explicit bSearchScore(bScore const& score, scoretype_t const& st)
    : m_score{score}
    , m_type{st}
    {}
  ~bSearchScore()
    {}
 
  bSearchScore& operator=(bScore const& score)
    { m_score = score;
      return *this;
    }
 
  bSearchScore operator-() const;
 
  bool operator>(bScore const& rhsc)
    { return realScore() > rhsc; }
  bool operator>(bSearchScore const& rhsc)
    { return realScore() > rhsc.realScore(); }
  bool operator>=(bSearchScore const& rhsc)
    { return realScore() >= rhsc.realScore(); }
  bool operator<(bScore const& rhsc)
    { return realScore() < rhsc; }
  bool operator<(bSearchScore const& rhsc)
    { return realScore() < rhsc.realScore(); }
  bool operator<=(bSearchScore const& rhsc)
    { return realScore() <= rhsc.realScore(); }
 
  constexpr bScore getScore() const
    { return m_score; }
  constexpr bScore realScore() const
    { return bSearchScore::isDrawScore(m_score) ? 0
              : ((m_score == SCORE_UNDEFINED) ? -SCORE_UNDEFINED : m_score);
    }
  constexpr bool isUndefinedScore() const
    { return (m_score == SCORE_UNDEFINED) || (m_score == -SCORE_UNDEFINED); }
  constexpr bool isInfiniteScore() const
    { return (m_score == SCORE_INFINITE) || (m_score == -SCORE_INFINITE); }
  constexpr bool isRealScore() const
    { return (!isUndefinedScore()) && (!isInfiniteScore()); }
  constexpr bool isFakeScore() const
    { return isUndefinedScore() || isInfiniteScore(); }
  constexpr bool isWinning() const
    { return (realScore() >= SCORE_INFINITE) && (realScore() <= SCORE_MATE); }
  inline bool improvesOn(bSearchScore const& sc)
    { return realScore() > sc.realScore(); }
  inline bool improvesOn(bScore const &margin, bSearchScore const& sc) const
    { return (realScore() - margin) >= sc.realScore(); }
  inline bool improvesOn(bScore const& sc)
    { return realScore() > realScore(sc); }
  inline bool improvesOn(bScore const &margin, bScore const& sc) const
    { return (realScore() - margin) >= realScore(sc); }
 
  std::string const operator+(std::string const& rhs)
    { return operator std::string() + rhs; }
  friend std::string const operator+(std::string const& lhs, bSearchScore const& sc)
    { return lhs + sc.operator std::string(); }
 
  friend bool operator>(bScore const& lhsc, bSearchScore const& rhsc)
    { return lhsc > rhsc.realScore(); }
  friend bool operator>=(bScore const& lhsc, bSearchScore const& rhsc)
    { return lhsc >= rhsc.realScore(); }
  friend bool operator<(bScore const& lhsc, bSearchScore const& rhsc)
    { return lhsc < rhsc.realScore(); }
  friend bool operator<=(bScore const& lhsc, bSearchScore const& rhsc)
    { return lhsc <= rhsc.realScore(); }
 
  inline bScore convergeScore()
    { m_score = convergeScore(m_score);
      return m_score;
    }
 
public:
  // class static
  static bScore convergeScore(bScore const score);
 
  constexpr static bScore realScore(bScore const score)
    { return bSearchScore::isDrawScore(score) ? 0
              : ((score == SCORE_UNDEFINED) ? -SCORE_UNDEFINED : score);
    }
  constexpr static bool isUndefinedScore(bScore const score)
    { return ((score == SCORE_UNDEFINED) || (score == -SCORE_UNDEFINED)); }
  constexpr static bool isInfiniteScore(bScore const score)
    { return (score == SCORE_INFINITE) || (score == -SCORE_INFINITE); }
  constexpr static bool isDrawScore(bScore const score)
    { return (score == SCORE_THEORETIC_DRAW) || (score == SCORE_PRACTICAL_DRAW); }
  constexpr static bool isRealScore(bScore const score)
    { return (!isUndefinedScore(score)) && (!isInfiniteScore(score)); }
  constexpr static bool isFakeScore(bScore const score)
    { return isUndefinedScore(score) || isInfiniteScore(score); }
 
  operator std::string() const;
 
private:
  union {
    uint32_t u_scoreInfo;
    struct {
      bScore m_score = -SCORE_UNDEFINED;
      scoretype_t m_type = tScoreType::SC_UNDEF;
    };
  };
};
 
//-----------------------------------------------------------------------
 
#endif // defined SEARCHSCORE_H
 
// eof