Bitboard.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */

 
#pragma once
 
#include <bit>
#include <cassert>
#include <cstddef> // IWYU pragma: keep - for size_t
#include <cstdint> // IWYU pragma: keep - for std::uint64_t
#include <iterator>
#include <libchess/board/BitboardIndex.hpp>
#include <libchess/board/Square.hpp>
#include <ranges>
#include <string>
#include <utility>
 
namespace chess::board {
 
using std::size_t;

struct Bitboard final {
    using Integer = std::uint64_t;

    constexpr Bitboard() noexcept = default;

    explicit constexpr Bitboard(Integer val) noexcept;

    [[nodiscard]] constexpr auto operator==(const Bitboard&) const noexcept -> bool = default;


    [[nodiscard]] constexpr auto any() const noexcept -> bool { return std::cmp_not_equal(value, 0); }

    [[nodiscard]] constexpr auto none() const noexcept -> bool { return std::cmp_equal(value, 0); }

    [[nodiscard]] constexpr auto count() const noexcept -> size_t { return static_cast<size_t>(std::popcount(value)); }

    [[nodiscard]] constexpr auto test(const Square square) const noexcept -> bool { return test(square.index()); }

    [[nodiscard]] constexpr auto test(BitboardIndex index) const noexcept -> bool;

    [[nodiscard]] constexpr auto first() const noexcept -> BitboardIndex;

    [[nodiscard]] constexpr auto last() const noexcept -> BitboardIndex;



    constexpr void set(const Square square) noexcept { set(square.index()); }

    constexpr void set(BitboardIndex index) noexcept;

    constexpr void unset(const Square square) noexcept { unset(square.index()); }

    constexpr void unset(BitboardIndex index) noexcept;

    constexpr void clear() noexcept { value = UINT64_C(0); }


    [[nodiscard]] constexpr auto to_int() const noexcept -> Integer { return value; }


    [[nodiscard]] constexpr auto indices() const noexcept;

    [[nodiscard]] constexpr auto squares() const noexcept;

    [[nodiscard]] constexpr auto subboards() const noexcept;



    [[nodiscard]] constexpr auto inverse() const noexcept -> Bitboard;

    constexpr auto operator&=(const Bitboard& other) noexcept -> Bitboard&;

    constexpr auto operator|=(const Bitboard& other) noexcept -> Bitboard&;

    constexpr auto operator^=(const Bitboard& other) noexcept -> Bitboard&;

    constexpr auto operator<<=(size_t num) noexcept -> Bitboard&;

    constexpr auto operator>>=(size_t num) noexcept -> Bitboard&;


    [[nodiscard, gnu::const]] static constexpr auto from_square(Square square) noexcept -> Bitboard;
 
private:
    Integer value { UINT64_C(0) };
};


[[nodiscard, gnu::const]] constexpr auto operator&(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard;

[[nodiscard, gnu::const]] constexpr auto operator|(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard;

[[nodiscard, gnu::const]] constexpr auto operator^(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard;

[[nodiscard, gnu::const]] constexpr auto operator<<(const Bitboard& board, size_t num) noexcept -> Bitboard;

[[nodiscard, gnu::const]] constexpr auto operator>>(const Bitboard& board, size_t num) noexcept -> Bitboard;

[[nodiscard]] auto print_ascii(Bitboard board) -> std::string;


namespace literals {

    [[nodiscard, gnu::const]] consteval auto operator""_bb(
        const unsigned long long value) noexcept // NOLINT(runtime/int)
        -> Bitboard
    {
        return Bitboard { static_cast<Bitboard::Integer>(value) };
    }
 
} // namespace literals
 
} // namespace chess::board
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
namespace chess::board {
 
constexpr Bitboard::Bitboard(const Integer val) noexcept
    : value { val }
{
}
 
constexpr auto Bitboard::from_square(const Square square) noexcept -> Bitboard
{
    return Bitboard { UINT64_C(1) << square.index() };
}
 
constexpr auto Bitboard::test(const BitboardIndex index) const noexcept -> bool
{
    assert(std::cmp_less_equal(index, MAX_BITBOARD_IDX));
 
    return std::cmp_not_equal(
        (value >> index) & UINT64_C(1),
        0);
}
 
constexpr void Bitboard::set(const BitboardIndex index) noexcept
{
    assert(std::cmp_less_equal(index, MAX_BITBOARD_IDX));
 
    value |= UINT64_C(1) << index;
}
 
constexpr void Bitboard::unset(const BitboardIndex index) noexcept
{
    assert(std::cmp_less_equal(index, MAX_BITBOARD_IDX));
 
    const Integer mask { UINT64_C(1) << index };
 
    value &= ~mask;
}
 
constexpr auto Bitboard::first() const noexcept -> BitboardIndex
{
    // same as number of leading zeroes
    return static_cast<BitboardIndex>(std::countr_zero(value));
}
 
constexpr auto Bitboard::last() const noexcept -> BitboardIndex
{
    if (none()) {
        [[unlikely]]; // this is probably an error condition, but we want this function to be noexcept
        return NUM_SQUARES;
    }
 
    const auto trailingZeroes = std::countl_zero(value);
 
    return static_cast<BitboardIndex>(NUM_SQUARES - trailingZeroes - 1);
}
 
constexpr auto Bitboard::operator&=(const Bitboard& other) noexcept -> Bitboard&
{
    value &= other.value;
    return *this;
}
 
constexpr auto Bitboard::operator|=(const Bitboard& other) noexcept -> Bitboard&
{
    value |= other.value;
    return *this;
}
 
constexpr auto Bitboard::operator^=(const Bitboard& other) noexcept -> Bitboard&
{
    value ^= other.value;
    return *this;
}
 
constexpr auto Bitboard::operator<<=(const size_t num) noexcept -> Bitboard&
{
    value <<= num;
    return *this;
}
 
constexpr auto Bitboard::operator>>=(const size_t num) noexcept -> Bitboard&
{
    value >>= num;
    return *this;
}
 
constexpr auto Bitboard::inverse() const noexcept -> Bitboard
{
    return Bitboard { ~value };
}
 
constexpr auto operator&(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard
{
    auto ret = lhs;
    ret &= rhs;
    return ret;
}
 
constexpr auto operator|(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard
{
    auto ret = lhs;
    ret |= rhs;
    return ret;
}
 
constexpr auto operator^(const Bitboard& lhs, const Bitboard& rhs) noexcept -> Bitboard
{
    auto ret = lhs;
    ret ^= rhs;
    return ret;
}
 
constexpr auto operator<<(const Bitboard& board, const size_t num) noexcept -> Bitboard
{
    auto ret = board;
    ret <<= num;
    return ret;
}
 
constexpr auto operator>>(const Bitboard& board, const size_t num) noexcept -> Bitboard
{
    auto ret = board;
    ret >>= num;
    return ret;
}
 
namespace detail {
 
    // an STL iterator that iterates the set bits in a bitboard, quickly scanning through them using bitscan
    struct BitboardIterator final {
        using value_type   = BitboardIndex;
        using element_type = value_type;
        using pointer      = value_type;
        using reference    = value_type;
 
        using difference_type = std::ptrdiff_t;
 
        using iterator_category = std::forward_iterator_tag;
        using iterator_concept  = std::forward_iterator_tag;
 
        consteval BitboardIterator() = default;
 
        explicit constexpr BitboardIterator(const Bitboard& bitboard)
            : value { bitboard.to_int() }
        {
        }
 
        constexpr auto operator==(const BitboardIterator& other) const noexcept -> bool = default;
 
        constexpr auto operator==([[maybe_unused]] std::default_sentinel_t sentinel) const noexcept -> bool
        {
            return std::cmp_equal(value, 0);
        }
 
        [[nodiscard]] constexpr auto operator*() const noexcept -> value_type
        {
            return static_cast<value_type>(std::countr_zero(value));
        }
 
        constexpr auto operator++() noexcept -> BitboardIterator&
        {
            assert(std::cmp_greater(value, 0));
 
            value &= value - UINT64_C(1);
 
            return *this;
        }
 
        [[nodiscard]] constexpr auto operator++(int) noexcept -> BitboardIterator
        {
            const auto ret { *this };
            ++*this;
            return ret;
        }
 
    private:
        Bitboard::Integer value { UINT64_C(0) };
    };
 
} // namespace detail
 
constexpr auto Bitboard::indices() const noexcept
{
    return std::ranges::subrange {
        detail::BitboardIterator { *this },
        detail::BitboardIterator { },
        count()
    };
}
 
constexpr auto Bitboard::squares() const noexcept
{
    return indices()
         | std::views::transform(Square::from_index);
}
 
constexpr auto Bitboard::subboards() const noexcept
{
    return indices()
         | std::views::transform(
             [](const BitboardIndex index) {
                 Bitboard board;
                 board.set(index);
                 return board;
             });
}
 
} // namespace chess::board