@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/algorithm/random_bipartition_shuffle.hpp

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * tlx/algorithm/random_bipartition_shuffle.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Manuel Penschuck <tlx@manuel.jetzt>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALGORITHM_RANDOM_BIPARTITION_SHUFFLE_HEADER
+#define TLX_ALGORITHM_RANDOM_BIPARTITION_SHUFFLE_HEADER
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <random>
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+/*!
+ * Similar to std::shuffle, but only generates a random bi-partition.
+ * In the result, the
+ *   the left  partition class is stored at positions 0 to size_left_partition-1
+ *   the right partition class is stored at positions size_left_partition to n
+ * where n = std::distance(begin, end).
+ *
+ * Each element is moved to the left partition with probability
+ * (size_left_partition / n). There are no guarantees on the order WITHIN a
+ * partition (which makes this function considerable faster than std::shuffle
+ * especially if partition sizes are unbalanced). The runtime complexity is
+ * linear in the size of the smaller partition class.
+ *
+ * \param begin                Iterator to the begin of the data frame
+ * \param end                  Iterator to the end of the data frame
+ * \param size_left_partition  Number of elements to be put into the left
+ *                             partition: 0 <= size_left_partition <= n
+ * \param urng                 Random number generator compatible with STL
+ *                             interface, e.g. std::mt19937
+ */
+template <typename RandomAccessIt, typename RandomBits>
+void random_bipartition_shuffle(RandomAccessIt begin, RandomAccessIt end,
+                                size_t size_left_partition, RandomBits& urng)
+{
+    const size_t size = std::distance(begin, end);
+    assert(size_left_partition <= size);
+
+    // ensure that both paritions are non-empty
+    const size_t size_right_partition = size - size_left_partition;
+    if (!size_left_partition || !size_right_partition)
+        return;
+
+    // this idea is borrow from GNU stdlibc++ and generates two random
+    // variates uniform on [0, a) and [0, b) respectively.
+    auto two_random_variates = [&urng](size_t a, size_t b) {
+        auto x = std::uniform_int_distribution<size_t>{0, (a * b) - 1}(urng);
+        return std::make_pair(x / b, x % b);
+    };
+
+    using std::swap; // allow ADL
+
+    // Perform a Fisher-Yates shuffle, but iterate only over the positions
+    // of the smaller partition.
+    if (size_left_partition < size_right_partition)
+    {
+        auto it = begin;
+
+        // To avoid wasted random bits, we draw two variates at once
+        // and shuffle two positions per iteration
+        for (size_t i = 1; i < size_left_partition; i += 2)
+        {
+            auto rand = two_random_variates(size - i + 1, size - i);
+            swap(*it++, *std::next(begin, size - 1 - rand.first));
+            swap(*it++, *std::next(begin, size - 1 - rand.second));
+        }
+
+        // In case the partition contains an odd number of elements,
+        // there's a special case for the last element
+        if (size_left_partition % 2)
+        {
+            auto x = std::uniform_int_distribution<size_t>{
+                size_left_partition - 1, size - 1}(urng);
+            swap(*it, *std::next(begin, x));
+        }
+    }
+    else
+    {
+        // Symmetric case to above, this time shuffling the right partition
+        auto it = std::next(begin, size - 1);
+
+        for (size_t i = size - 2; i >= size_left_partition; i -= 2)
+        {
+            auto rand = two_random_variates(i + 2, i + 1);
+            swap(*it--, *std::next(begin, rand.first));
+            swap(*it--, *std::next(begin, rand.second));
+        }
+
+        if (size_right_partition % 2)
+        {
+            auto x = std::uniform_int_distribution<size_t>{
+                0, size_left_partition}(urng);
+            swap(*it--, *std::next(begin, x));
+        }
+    }
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_RANDOM_BIPARTITION_SHUFFLE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/algorithm.hpp

@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * tlx/algorithm.hpp
+ *
+ * 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_ALGORITHM_HEADER
+#define TLX_ALGORITHM_HEADER
+
+//! \defgroup tlx_algorithm Algorithms
+//! Algorithms for iterators and ranges
+
+/*[[[perl
+foreach (sort glob("tlx/algorithm/"."*.hpp")) {
+  print "#include <$_> // NOLINT(misc-include-cleaner)\n";
+}
+]]]*/
+#include <tlx/algorithm/exclusive_scan.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/is_sorted_cmp.hpp>  // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/merge_advance.hpp>  // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/merge_combine.hpp>  // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/multisequence_partition.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/multisequence_selection.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/multiway_merge.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/multiway_merge_splitting.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/parallel_multiway_merge.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/algorithm/random_bipartition_shuffle.hpp> // NOLINT(misc-include-cleaner)
+// [[[end]]]
+
+#endif // !TLX_ALGORITHM_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/allocator_base.hpp

@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * tlx/allocator_base.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALLOCATOR_BASE_HEADER
+#define TLX_ALLOCATOR_BASE_HEADER
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+
+namespace tlx {
+
+template <typename Type>
+class AllocatorBase
+{
+    static constexpr bool debug = true;
+
+public:
+    using value_type = Type;
+    using pointer = Type*;
+    using const_pointer = const Type*;
+    using reference = Type&;
+    using const_reference = const Type&;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    //! C++11 type flag
+    using is_always_equal = std::true_type;
+    //! C++11 type flag
+    using propagate_on_container_move_assignment = std::true_type;
+
+    //! Returns the address of x.
+    pointer address(reference x) const noexcept
+    {
+        return std::addressof(x);
+    }
+
+    //! Returns the address of x.
+    const_pointer address(const_reference x) const noexcept
+    {
+        return std::addressof(x);
+    }
+
+    //! Maximum size possible to allocate
+    size_type max_size() const noexcept
+    {
+        return size_t(-1) / sizeof(Type);
+    }
+
+#if __cplusplus >= 201103L
+    //! Constructs an element object on the location pointed by p.
+    template <typename SubType, typename... Args>
+    void construct(SubType* p, Args&&... args)
+        noexcept(std::is_nothrow_constructible<SubType, Args...>::value)
+    {
+        ::new (static_cast<void*>(p)) SubType(std::forward<Args>(args)...);
+    }
+
+    //! Destroys in-place the object pointed by p.
+    template <typename SubType>
+    void destroy(SubType* p) const
+        noexcept(std::is_nothrow_destructible<SubType>::value)
+    {
+        p->~SubType();
+    }
+#else
+    //! Constructs an element object on the location pointed by p.
+    void construct(pointer p, const_reference value)
+    {
+        ::new (static_cast<void*>(p)) Type(value);
+    }
+
+#if defined(_MSC_VER)
+// disable false-positive warning C4100: 'p': unreferenced formal parameter
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+    //! Destroys in-place the object pointed by p.
+    void destroy(pointer p) const noexcept
+    {
+        p->~Type();
+    }
+#if defined(_MSC_VER)
+#pragma warning(push)
+#endif
+#endif
+};
+
+} // namespace tlx
+
+#endif // !TLX_ALLOCATOR_BASE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/backtrace.hpp

@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * tlx/backtrace.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2008-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_BACKTRACE_HEADER
+#define TLX_BACKTRACE_HEADER
+
+#include <tlx/define/attribute_format_printf.hpp>
+#include <cstdio>
+
+namespace tlx {
+
+//! \name Stack Backtrace Printing
+//! \{
+
+/*!
+ * Print a plain hex stack backtrace of the called function to FILE* out.
+ */
+void print_raw_backtrace(FILE* out = stderr, unsigned int max_frames = 63);
+
+/*!
+ * Print a plain hex stack backtrace of the called function to FILE* out,
+ * prefixed with the given printf formatted output.
+ */
+void print_raw_backtrace(FILE* out, unsigned int max_frames, const char* fmt,
+                         ...) TLX_ATTRIBUTE_FORMAT_PRINTF(3, 4);
+
+/*!
+ * Print a demangled stack backtrace of the caller function to FILE* out.
+ *
+ * \warning The binary has to be compiled with <tt>-rdynamic</tt> for meaningful
+ * output.
+ */
+void print_cxx_backtrace(FILE* out = stderr, unsigned int max_frames = 63);
+
+/*!
+ * Install SIGSEGV signal handler and output backtrace on segmentation fault.
+ * Compile with `-rdynamic` for more useful output.
+ */
+void enable_segv_backtrace();
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_BACKTRACE_HEADER
+
+/******************************************************************************/