bmat16.hpp

Go to the documentation of this file.

//****************************************************************************//
//    Copyright (C) 2018-2024 Finn Smith <fls3@st-andrews.ac.uk>              //
//    Copyright (C) 2018-2024 James Mitchell <jdm3@st-andrews.ac.uk>          //
//    Copyright (C) 2018-2024 Florent Hivert <Florent.Hivert@lisn.fr>,        //
//                                                                            //
//  This file is part of HP-Combi <https://github.com/libsemigroups/HPCombi>  //
//                                                                            //
//  HP-Combi is free software: you can redistribute it and/or modify it       //
//  under the terms of the GNU General Public License as published by the     //
//  Free Software Foundation, either version 3 of the License, or             //
//  (at your option) any later version.                                       //
//                                                                            //
//  HP-Combi is distributed in the hope that it will be useful, but WITHOUT   //
//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     //
//  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License      //
//  for  more details.                                                        //
//                                                                            //
//  You should have received a copy of the GNU General Public License along   //
//  with HP-Combi. If not, see <https://www.gnu.org/licenses/>.               //
//****************************************************************************//
 
// This file contains a declaration of fast boolean matrices up to dimension 16.
 
#ifndef HPCOMBI_BMAT16_HPP_
#define HPCOMBI_BMAT16_HPP_
 
#include <array>     // for array
#include <cstddef>   // for size_t
#include <cstdint>   // for uint64_t, uint8_t
#include <iostream>  // for ostream
#include <utility>   // for pair, swap
#include <vector>    // for vector
 
#include "bmat8.hpp"  // for BMat8
#include "debug.hpp"  // for HPCOMBI_ASSERT
 
#include "simde/x86/avx2.h"
 
namespace HPCombi {
using xpu16 = uint16_t __attribute__((vector_size(32)));
using xpu64 = uint64_t __attribute__((vector_size(32)));

xpu64 to_line(xpu64 vect);

xpu64 to_block(xpu64 vect);

class BMat16 {
 public:
    BMat16() noexcept = default;

    explicit BMat16(xpu64 mat) noexcept : _data{mat} {}

    explicit BMat16(uint64_t n0, uint64_t n1, uint64_t n2,
                    uint64_t n3) noexcept;

    explicit BMat16(std::vector<std::vector<bool>> const &mat) noexcept;

    BMat16(BMat16 const &) noexcept = default;

    BMat16(BMat16 &&) noexcept = default;

    BMat16 &operator=(BMat16 const &) noexcept = default;

    BMat16 &operator=(BMat16 &&) noexcept = default;

    ~BMat16() = default;

    bool operator==(BMat16 const &that) const noexcept;

    bool operator!=(BMat16 const &that) const noexcept {
        return !(*this == that);
    }

    bool operator<(BMat16 const &that) const noexcept;

    bool operator>(BMat16 const &that) const noexcept;

    bool operator()(size_t i, size_t j) const noexcept;

    void set(size_t i, size_t j, bool val) noexcept;

    std::array<std::array<bool, 16>, 16> to_array() const noexcept;

    BMat16 operator|(BMat16 const &that) const noexcept {
        return BMat16(_data | that._data);
    }

    BMat16 transpose_naive() const noexcept;

    BMat16 transpose() const noexcept;

    BMat16 mult_transpose(BMat16 const &that) const noexcept;

    BMat16 mult_4bmat8(BMat16 const &that) const noexcept;

    BMat16 operator*(BMat16 const &that) const noexcept {
        return mult_transpose(that.transpose());
    }

    BMat16 mult_naive(BMat16 const &that) const noexcept;

    BMat16 mult_naive_array(BMat16 const &that) const noexcept;

    size_t nr_rows() const noexcept;

    // Not noexcept because it constructs a vector
    std::vector<uint16_t> rows() const;

    static BMat16 one(size_t dim = 16) noexcept {
        HPCOMBI_ASSERT(dim <= 16);
        static std::array<uint64_t, 9> const ones = {0,
                                                     1,
                                                     0x201,
                                                     0x40201,
                                                     0x8040201,
                                                     0x1008040201,
                                                     0x201008040201,
                                                     0x40201008040201,
                                                     0x8040201008040201};
        return BMat16(ones[dim >= 8 ? 8 : dim], 0, 0,
                      ones[dim >= 8 ? dim - 8 : 0]);
    }

    // Not noexcept because random things aren't
    static BMat16 random();

    // Not noexcept because BMat16::random above is not
    static BMat16 random(size_t dim);
 
    void swap(BMat16 &that) noexcept { std::swap(this->_data, that._data); }

    // Not noexcept
    std::ostream &write(std::ostream &os) const;
 
 private:
    xpu64 _data;
};
 
}  // namespace HPCombi
 
#include "bmat16_impl.hpp"
 
#endif  // HPCOMBI_BMAT16_HPP_