@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * 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

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * 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
+
+/******************************************************************************/