epu8.hpp

Go to the documentation of this file.

//****************************************************************************//
//     Copyright (C) 2016-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/>.               //
//****************************************************************************//

 
#ifndef HPCOMBI_EPU8_HPP_
#define HPCOMBI_EPU8_HPP_
 
#include <array>    // for array
#include <cstddef>  // for size_t
#include <cstdint>  // for uint8_t, uint64_t, int8_t
#include <ostream>  // for ostream
#include <string>   // for string
 
#include "builder.hpp"       // for TPUBuild
#include "debug.hpp"         // for HPCOMBI_ASSERT
#include "vect_generic.hpp"  // for VectGeneric
 
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-default"
#pragma GCC diagnostic ignored "-Wpacked"
#endif
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbitwise-instead-of-logical"
#endif
#include "simde/x86/sse4.1.h"  // for simde_mm_max_epu8, simde...
#include "simde/x86/sse4.2.h"  // for ???
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
 
namespace HPCombi {

inline constexpr uint8_t
operator"" _u8(unsigned long long arg) noexcept {  // NOLINT
    return static_cast<uint8_t>(arg);
}

using epu8 = uint8_t __attribute__((vector_size(16)));
 
static_assert(alignof(epu8) == 16,
              "epu8 type is not properly aligned by the compiler !");

constexpr TPUBuild<epu8> Epu8{};

inline bool is_all_zero(epu8 a) noexcept { return simde_mm_testz_si128(a, a); }
inline bool is_all_one(epu8 a) noexcept {
    return simde_mm_testc_si128(a, Epu8(0xFF));
}

inline bool equal(epu8 a, epu8 b) noexcept {
    return is_all_zero(simde_mm_xor_si128(a, b));
}

inline bool not_equal(epu8 a, epu8 b) noexcept { return !equal(a, b); }

inline epu8 permuted_ref(epu8 a, epu8 b) noexcept;

inline epu8 permuted(epu8 a, epu8 b) noexcept {
    return simde_mm_shuffle_epi8(a, b);
}

inline epu8 shifted_right(epu8 a) noexcept {
    return simde_mm_bslli_si128(a, 1);
}

inline epu8 shifted_left(epu8 a) noexcept { return simde_mm_bsrli_si128(a, 1); }

inline epu8 reverted(epu8 a) noexcept { return permuted(a, Epu8.rev()); }

inline epu8 min(epu8 a, epu8 b) noexcept { return simde_mm_min_epu8(a, b); }
inline epu8 max(epu8 a, epu8 b) noexcept { return simde_mm_max_epu8(a, b); }

inline bool is_sorted(epu8 a) noexcept;
inline epu8 sorted(epu8 a) noexcept;
inline epu8 sorted8(epu8 a) noexcept;
inline epu8 revsorted(epu8 a) noexcept;
inline epu8 revsorted8(epu8 a) noexcept;

inline epu8 sort_perm(epu8 &a) noexcept;
inline epu8 sort8_perm(epu8 &a) noexcept;

inline void merge(epu8 &a, epu8 &b) noexcept;
 
#ifdef SIMDE_X86_SSE4_2_NATIVE
inline epu8 permutation_of_cmpestrm(epu8 a, epu8 b) noexcept;
#endif

inline epu8 permutation_of_ref(epu8 a, epu8 b) noexcept;

inline epu8 permutation_of(epu8 a, epu8 b) noexcept;

constexpr uint64_t prime = 0x9e3779b97f4a7bb9;

inline epu8 random_epu8(uint16_t bnd);

inline epu8 remove_dups(epu8 a, uint8_t repl = 0) noexcept;

 
inline uint8_t horiz_sum_ref(epu8) noexcept;

 
inline uint8_t horiz_sum_gen(epu8) noexcept;

inline uint8_t horiz_sum4(epu8) noexcept;

inline uint8_t horiz_sum3(epu8) noexcept;

inline uint8_t horiz_sum(epu8 v) noexcept { return horiz_sum3(v); }

inline epu8 partial_sums_ref(epu8) noexcept;

inline epu8 partial_sums_gen(epu8) noexcept;

inline epu8 partial_sums_round(epu8) noexcept;

inline epu8 partial_sums(epu8 v) noexcept { return partial_sums_round(v); }

inline uint8_t horiz_max_ref(epu8) noexcept;

inline uint8_t horiz_max_gen(epu8) noexcept;

inline uint8_t horiz_max4(epu8) noexcept;

inline uint8_t horiz_max3(epu8) noexcept;

inline uint8_t horiz_max(epu8 v) noexcept { return horiz_max4(v); }

inline epu8 partial_max_ref(epu8) noexcept;

inline epu8 partial_max_gen(epu8) noexcept;

inline epu8 partial_max_round(epu8) noexcept;

inline epu8 partial_max(epu8 v) noexcept { return partial_max_round(v); }

inline uint8_t horiz_min_ref(epu8) noexcept;

inline uint8_t horiz_min_gen(epu8) noexcept;

inline uint8_t horiz_min4(epu8) noexcept;

inline uint8_t horiz_min3(epu8) noexcept;

inline uint8_t horiz_min(epu8 v) noexcept { return horiz_min4(v); }

inline epu8 partial_min_ref(epu8) noexcept;

inline epu8 partial_min_gen(epu8) noexcept;

inline epu8 partial_min_round(epu8) noexcept;

inline epu8 partial_min(epu8 v) noexcept { return partial_min_round(v); }

inline epu8 eval16_ref(epu8 v) noexcept;

inline epu8 eval16_arr(epu8 v) noexcept;

inline epu8 eval16_cycle(epu8 v) noexcept;

inline epu8 eval16_popcount(epu8 v) noexcept;

inline epu8 eval16(epu8 v) noexcept { return eval16_cycle(v); }

inline uint64_t first_diff_ref(epu8 a, epu8 b, size_t bound = 16) noexcept;
 
#ifdef SIMDE_X86_SSE4_2_NATIVE
inline uint64_t first_diff_cmpstr(epu8 a, epu8 b, size_t bound = 16) noexcept;
#endif

inline uint64_t first_diff_mask(epu8 a, epu8 b, size_t bound = 16) noexcept;

inline uint64_t first_diff(epu8 a, epu8 b, size_t bound = 16) noexcept {
    return first_diff_mask(a, b, bound);
}

inline uint64_t last_diff_ref(epu8 a, epu8 b, size_t bound = 16) noexcept;
 
#ifdef SIMDE_X86_SSE4_2_NATIVE
inline uint64_t last_diff_cmpstr(epu8 a, epu8 b, size_t bound = 16) noexcept;
#endif

inline uint64_t last_diff_mask(epu8 a, epu8 b, size_t bound = 16) noexcept;

inline uint64_t last_diff(epu8 a, epu8 b, size_t bound = 16) noexcept {
    return last_diff_mask(a, b, bound);
}

inline bool less(epu8 a, epu8 b) noexcept;
inline int8_t less_partial(epu8 a, epu8 b, int k) noexcept;

inline uint64_t first_zero(epu8 v, int bnd) noexcept;
inline uint64_t last_zero(epu8 v, int bnd) noexcept;
inline uint64_t first_non_zero(epu8 v, int bnd) noexcept;
inline uint64_t last_non_zero(epu8 v, int bnd) noexcept;

inline epu8 popcount16(epu8 v) noexcept;

inline bool is_partial_transformation(epu8 v, const size_t k = 16) noexcept;

inline bool is_transformation(epu8 v, const size_t k = 16) noexcept;

inline bool is_partial_permutation(epu8 v, const size_t k = 16) noexcept;
 
#ifdef SIMDE_X86_SSE4_2_NATIVE
inline bool is_permutation_cpmestri(epu8 v, const size_t k = 16) noexcept;
#endif
inline bool is_permutation_sort(epu8 v, const size_t k = 16) noexcept;

inline bool is_permutation_eval(epu8 v, const size_t k = 16) noexcept;

inline bool is_permutation(epu8 v, const size_t k = 16) noexcept;
 
}  // namespace HPCombi
 
namespace std {
 
inline std::ostream &operator<<(std::ostream &stream, HPCombi::epu8 const &a);
 
inline std::string to_string(HPCombi::epu8 const &a);

}  // namespace std
 
#include "epu8_impl.hpp"
 
#endif  // HPCOMBI_EPU8_HPP_