@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/tlx/math/popcount.hpp

@@ -1,173 +0,0 @@
-/*******************************************************************************
- * tlx/math/popcount.hpp
- *
- * popcount() population count number of one bits - mainly for portability.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_POPCOUNT_HEADER
-#define TLX_MATH_POPCOUNT_HEADER
-
-#include <cstdint>
-#include <cstdlib>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-// popcount() - count one bits
-
-//! popcount (count one bits) - generic SWAR implementation
-static inline unsigned popcount_generic8(std::uint8_t x)
-{
-    x = x - ((x >> 1) & 0x55);
-    x = (x & 0x33) + ((x >> 2) & 0x33);
-    return static_cast<std::uint8_t>((x + (x >> 4)) & 0x0F);
-}
-
-//! popcount (count one bits) - generic SWAR implementation
-static inline unsigned popcount_generic16(std::uint16_t x)
-{
-    x = x - ((x >> 1) & 0x5555);
-    x = (x & 0x3333) + ((x >> 2) & 0x3333);
-    return static_cast<std::uint16_t>(((x + (x >> 4)) & 0x0F0F) * 0x0101) >> 8;
-}
-
-//! popcount (count one bits) -
-//! generic SWAR implementation from https://stackoverflow.com/questions/109023
-static inline unsigned popcount_generic32(std::uint32_t x)
-{
-    x = x - ((x >> 1) & 0x55555555);
-    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
-    return (((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
-}
-
-//! popcount (count one bits) - generic SWAR implementation
-static inline unsigned popcount_generic64(std::uint64_t x)
-{
-    x = x - ((x >> 1) & 0x5555555555555555);
-    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
-    return (((x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F) * 0x0101010101010101) >> 56;
-}
-
-/******************************************************************************/
-
-#if defined(__GNUC__) || defined(__clang__)
-
-//! popcount (count one bits)
-static inline unsigned popcount(unsigned i)
-{
-    return static_cast<unsigned>(__builtin_popcount(i));
-}
-
-//! popcount (count one bits)
-static inline unsigned popcount(int i)
-{
-    return popcount(static_cast<unsigned>(i));
-}
-
-//! popcount (count one bits)
-static inline unsigned popcount(unsigned long i)
-{
-    return static_cast<unsigned>(__builtin_popcountl(i));
-}
-
-//! popcount (count one bits)
-static inline unsigned popcount(long i)
-{
-    return popcount(static_cast<unsigned long>(i));
-}
-
-//! popcount (count one bits)
-static inline unsigned popcount(unsigned long long i)
-{
-    return static_cast<unsigned>(__builtin_popcountll(i));
-}
-
-//! popcount (count one bits)
-static inline unsigned popcount(long long i)
-{
-    return popcount(static_cast<unsigned long long>(i));
-}
-
-#elif defined(_MSC_VER)
-
-//! popcount (count one bits)
-template <typename Integral>
-inline unsigned popcount(Integral i)
-{
-    if (sizeof(i) <= sizeof(int))
-        return __popcnt(i);
-    else
-    {
-#if defined(_WIN64)
-        return __popcnt64(i);
-#else
-        return popcount_generic64(i);
-#endif
-    }
-}
-
-#else
-
-//! popcount (count one bits)
-template <typename Integral>
-inline unsigned popcount(Integral i)
-{
-    if (sizeof(i) <= sizeof(std::uint8_t))
-        return popcount_generic8(i);
-    else if (sizeof(i) <= sizeof(std::uint16_t))
-        return popcount_generic16(i);
-    else if (sizeof(i) <= sizeof(std::uint32_t))
-        return popcount_generic32(i);
-    else if (sizeof(i) <= sizeof(std::uint64_t))
-        return popcount_generic64(i);
-    else
-        abort();
-}
-
-#endif
-
-/******************************************************************************/
-// popcount range
-
-static inline size_t popcount(const void* data, size_t size)
-{
-    const std::uint8_t* begin = reinterpret_cast<const std::uint8_t*>(data);
-    const std::uint8_t* end = begin + size;
-    size_t total = 0;
-    while (begin + 7 < end)
-    {
-        total += popcount(*reinterpret_cast<const std::uint64_t*>(begin));
-        begin += 8;
-    }
-    if (begin + 3 < end)
-    {
-        total += popcount(*reinterpret_cast<const std::uint32_t*>(begin));
-        begin += 4;
-    }
-    while (begin < end)
-    {
-        total += popcount(*begin++);
-    }
-    return total;
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_POPCOUNT_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/power_to_the.hpp

@@ -1,44 +0,0 @@
-/*******************************************************************************
- * tlx/math/power_to_the.hpp
- *
- * power_to_the<D>(x) raises x to the D-th power using log(D) unrolled
- * multiplications.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2019 Manuel Penschuck <tlx@manuel.jetzt>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_POWER_TO_THE_HEADER
-#define TLX_MATH_POWER_TO_THE_HEADER
-
-#include <tlx/math/div_ceil.hpp>
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-//! power_to_the<D>(x)
-
-//! returns x raised to the power of D using log(D) explicit multiplications.
-template <unsigned D, typename T>
-static constexpr T power_to_the(T x)
-{
-    // Compiler optimize two calls to the same recursion into one
-    // Tested with GCC 4+, Clang 3+, MSVC 15+
-    return D < 1  ? 1 :
-           D == 1 ? x :
-                    power_to_the<D / 2>(x) * power_to_the<div_ceil(D, 2)>(x);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_POWER_TO_THE_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/rol.hpp

@@ -1,112 +0,0 @@
-/*******************************************************************************
- * tlx/math/rol.hpp
- *
- * rol32() to rotate bits left - mainly for portability.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_ROL_HEADER
-#define TLX_MATH_ROL_HEADER
-
-#include <cstdint>
-
-#ifdef _MSC_VER
-#include <cstdlib>
-#endif
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-// rol32() - rotate bits left in 32-bit integers
-
-//! rol32 - generic implementation
-static inline std::uint32_t rol32_generic(const std::uint32_t& x, int i)
-{
-    return (x << static_cast<std::uint32_t>(i & 31)) |
-           (x >> static_cast<std::uint32_t>((32 - (i & 31)) & 31));
-}
-
-#if (defined(__GNUC__) || defined(__clang__)) &&                               \
-    (defined(__i386__) || defined(__x86_64__))
-
-//! rol32 - gcc/clang assembler
-static inline std::uint32_t rol32(const std::uint32_t& x, int i)
-{
-    std::uint32_t x1 = x;
-    asm("roll %%cl,%0" : "=r"(x1) : "0"(x1), "c"(i));
-    return x1;
-}
-
-#elif defined(_MSC_VER)
-
-//! rol32 - MSVC intrinsic
-static inline std::uint32_t rol32(const std::uint32_t& x, int i)
-{
-    return _rotl(x, i);
-}
-
-#else
-
-//! rol32 - generic
-static inline std::uint32_t rol32(const std::uint32_t& x, int i)
-{
-    return rol32_generic(x, i);
-}
-
-#endif
-
-/******************************************************************************/
-// rol64() - rotate bits left in 64-bit integers
-
-//! rol64 - generic implementation
-static inline std::uint64_t rol64_generic(const std::uint64_t& x, int i)
-{
-    return (x << static_cast<std::uint64_t>(i & 63)) |
-           (x >> static_cast<std::uint64_t>((64 - (i & 63)) & 63));
-}
-
-#if (defined(__GNUC__) || defined(__clang__)) && defined(__x86_64__)
-
-//! rol64 - gcc/clang assembler
-static inline std::uint64_t rol64(const std::uint64_t& x, int i)
-{
-    std::uint64_t x1 = x;
-    asm("rolq %%cl,%0" : "=r"(x1) : "0"(x1), "c"(i));
-    return x1;
-}
-
-#elif defined(_MSC_VER)
-
-//! rol64 - MSVC intrinsic
-static inline std::uint64_t rol64(const std::uint64_t& x, int i)
-{
-    return _rotl64(x, i);
-}
-
-#else
-
-//! rol64 - generic
-static inline std::uint64_t rol64(const std::uint64_t& x, int i)
-{
-    return rol64_generic(x, i);
-}
-
-#endif
-
-/******************************************************************************/
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_ROL_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/ror.hpp

@@ -1,112 +0,0 @@
-/*******************************************************************************
- * tlx/math/ror.hpp
- *
- * ror32() to rotate bits right - mainly for portability.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_ROR_HEADER
-#define TLX_MATH_ROR_HEADER
-
-#include <cstdint>
-
-#ifdef _MSC_VER
-#include <cstdlib>
-#endif
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-// ror32() - rotate bits right in 32-bit integers
-
-//! ror32 - generic implementation
-static inline std::uint32_t ror32_generic(const std::uint32_t& x, int i)
-{
-    return (x >> static_cast<std::uint32_t>(i & 31)) |
-           (x << static_cast<std::uint32_t>((32 - (i & 31)) & 31));
-}
-
-#if (defined(__GNUC__) || defined(__clang__)) &&                               \
-    (defined(__i386__) || defined(__x86_64__))
-
-//! ror32 - gcc/clang assembler
-static inline std::uint32_t ror32(const std::uint32_t& x, int i)
-{
-    std::uint32_t x1 = x;
-    asm("rorl %%cl,%0" : "=r"(x1) : "0"(x1), "c"(i));
-    return x1;
-}
-
-#elif defined(_MSC_VER)
-
-//! ror32 - MSVC intrinsic
-static inline std::uint32_t ror32(const std::uint32_t& x, int i)
-{
-    return _rotr(x, i);
-}
-
-#else
-
-//! ror32 - generic
-static inline std::uint32_t ror32(const std::uint32_t& x, int i)
-{
-    return ror32_generic(x, i);
-}
-
-#endif
-
-/******************************************************************************/
-// ror64() - rotate bits right in 64-bit integers
-
-//! ror64 - generic implementation
-static inline std::uint64_t ror64_generic(const std::uint64_t& x, int i)
-{
-    return (x >> static_cast<std::uint64_t>(i & 63)) |
-           (x << static_cast<std::uint64_t>((64 - (i & 63)) & 63));
-}
-
-#if (defined(__GNUC__) || defined(__clang__)) && defined(__x86_64__)
-
-//! ror64 - gcc/clang assembler
-static inline std::uint64_t ror64(const std::uint64_t& x, int i)
-{
-    std::uint64_t x1 = x;
-    asm("rorq %%cl,%0" : "=r"(x1) : "0"(x1), "c"(i));
-    return x1;
-}
-
-#elif defined(_MSC_VER)
-
-//! ror64 - MSVC intrinsic
-static inline std::uint64_t ror64(const std::uint64_t& x, int i)
-{
-    return _rotr64(x, i);
-}
-
-#else
-
-//! ror64 - generic
-static inline std::uint64_t ror64(const std::uint64_t& x, int i)
-{
-    return ror64_generic(x, i);
-}
-
-#endif
-
-/******************************************************************************/
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_ROR_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/round_to_power_of_two.hpp

@@ -1,121 +0,0 @@
-/*******************************************************************************
- * tlx/math/round_to_power_of_two.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2007-2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_ROUND_TO_POWER_OF_TWO_HEADER
-#define TLX_MATH_ROUND_TO_POWER_OF_TWO_HEADER
-
-#include <cstddef>
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-// round_up_to_power_of_two()
-
-template <typename Integral>
-static inline Integral round_up_to_power_of_two_template(Integral n)
-{
-    --n;
-    for (size_t k = 1; k != 8 * sizeof(n); k <<= 1)
-    {
-        n |= n >> k;
-    }
-    ++n;
-    return n;
-}
-
-/******************************************************************************/
-// round_up_to_power_of_two()
-
-//! does what it says: round up to next power of two
-static inline int round_up_to_power_of_two(int i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-//! does what it says: round up to next power of two
-static inline unsigned int round_up_to_power_of_two(unsigned int i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-//! does what it says: round up to next power of two
-static inline long round_up_to_power_of_two(long i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-//! does what it says: round up to next power of two
-static inline unsigned long round_up_to_power_of_two(unsigned long i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-//! does what it says: round up to next power of two
-static inline long long round_up_to_power_of_two(long long i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-//! does what it says: round up to next power of two
-static inline unsigned long long round_up_to_power_of_two(unsigned long long i)
-{
-    return round_up_to_power_of_two_template(i);
-}
-
-/******************************************************************************/
-// round_down_to_power_of_two()
-
-//! does what it says: round down to next power of two
-static inline int round_down_to_power_of_two(int i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! does what it says: round down to next power of two
-static inline unsigned int round_down_to_power_of_two(unsigned int i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! does what it says: round down to next power of two
-static inline long round_down_to_power_of_two(long i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! does what it says: round down to next power of two
-static inline unsigned long round_down_to_power_of_two(unsigned long i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! does what it says: round down to next power of two
-static inline long long round_down_to_power_of_two(long long i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! does what it says: round down to next power of two
-static inline unsigned long long round_down_to_power_of_two(
-    unsigned long long i)
-{
-    return round_up_to_power_of_two(i + 1) >> 1;
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_ROUND_TO_POWER_OF_TWO_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/round_up.hpp

@@ -1,36 +0,0 @@
-/*******************************************************************************
- * tlx/math/round_up.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2019 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_ROUND_UP_HEADER
-#define TLX_MATH_ROUND_UP_HEADER
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-// round_up() - round n up to the next multiple of k
-
-//! round n up to the next multiple of k, for n and k positive!
-template <typename IntegralN, typename IntegralK>
-static constexpr auto round_up(const IntegralN& n,
-                               const IntegralK& k) -> decltype(n + k)
-{
-    return ((n + k - 1) / k) * k;
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_ROUND_UP_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math/sgn.hpp

@@ -1,38 +0,0 @@
-/*******************************************************************************
- * tlx/math/sgn.hpp
- *
- * sgn() return the signum (-1, 0, +1) of a value.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_SGN_HEADER
-#define TLX_MATH_SGN_HEADER
-
-namespace tlx {
-
-//! \addtogroup tlx_math
-//! \{
-
-/******************************************************************************/
-//! sgn() - signum
-
-//! return the signum (-1, 0, +1) of a value.
-template <typename T>
-int sgn(const T& val)
-{
-    // from https://stackoverflow.com/questions/1903954
-    return (T(0) < val) - (val < T(0));
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_MATH_SGN_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/math.hpp

@@ -1,46 +0,0 @@
-/*******************************************************************************
- * tlx/math.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MATH_HEADER
-#define TLX_MATH_HEADER
-
-//! \defgroup tlx_math Math Functions
-//! Simple math functions
-
-/*[[[perl
-foreach (sort glob("tlx/math/"."*.hpp")) {
-  print "#include <$_> // NOLINT(misc-include-cleaner)\n"
-}
-]]]*/
-#include <tlx/math/abs_diff.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/aggregate.hpp>             // NOLINT(misc-include-cleaner)
-#include <tlx/math/aggregate_min_max.hpp>     // NOLINT(misc-include-cleaner)
-#include <tlx/math/bswap.hpp>                 // NOLINT(misc-include-cleaner)
-#include <tlx/math/bswap_be.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/bswap_le.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/clz.hpp>                   // NOLINT(misc-include-cleaner)
-#include <tlx/math/ctz.hpp>                   // NOLINT(misc-include-cleaner)
-#include <tlx/math/div_ceil.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/ffs.hpp>                   // NOLINT(misc-include-cleaner)
-#include <tlx/math/integer_log2.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/math/is_power_of_two.hpp>       // NOLINT(misc-include-cleaner)
-#include <tlx/math/polynomial_regression.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/math/popcount.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/power_to_the.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/math/rol.hpp>                   // NOLINT(misc-include-cleaner)
-#include <tlx/math/ror.hpp>                   // NOLINT(misc-include-cleaner)
-#include <tlx/math/round_to_power_of_two.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/math/round_up.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/math/sgn.hpp>                   // NOLINT(misc-include-cleaner)
-// [[[end]]]
-
-#endif // !TLX_MATH_HEADER
-
-/******************************************************************************/