@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,177 @@
+/*******************************************************************************
+ * tlx/algorithm/merge_advance.hpp
+ *
+ * Variants of binary merge with output size limit.
+ *
+ * Copied and modified from STXXL, see http://stxxl.org, which itself extracted
+ * it from MCSTL http://algo2.iti.uni-karlsruhe.de/singler/mcstl/. Both are
+ * distributed under the Boost Software License, Version 1.0.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2007 Johannes Singler <singler@ira.uka.de>
+ * Copyright (C) 2014-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALGORITHM_MERGE_ADVANCE_HEADER
+#define TLX_ALGORITHM_MERGE_ADVANCE_HEADER
+
+#include <algorithm>
+#include <iterator>
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+/*!
+ * Merge routine being able to merge only the \c max_size smallest elements.
+ *
+ * The \c begin iterators are advanced accordingly, they might not reach \c end,
+ * in contrast to the usual variant.
+ *
+ * \param begin1 Begin iterator of first sequence.
+ * \param end1 End iterator of first sequence.
+ * \param begin2 Begin iterator of second sequence.
+ * \param end2 End iterator of second sequence.
+ * \param target Target begin iterator.
+ * \param max_size Maximum number of elements to merge.
+ * \param comp Comparator.
+ * \return Output end iterator.
+ */
+template <typename RandomAccessIterator1, typename RandomAccessIterator2,
+          typename OutputIterator, typename DiffType, typename Comparator>
+OutputIterator merge_advance_usual(RandomAccessIterator1& begin1,
+                                   RandomAccessIterator1 end1,
+                                   RandomAccessIterator2& begin2,
+                                   RandomAccessIterator2 end2,
+                                   OutputIterator target, DiffType max_size,
+                                   Comparator comp)
+{
+    while (begin1 != end1 && begin2 != end2 && max_size > 0)
+    {
+        // array1[i1] < array0[i0]
+        if (comp(*begin2, *begin1))
+            *target++ = *begin2++;
+        else
+            *target++ = *begin1++;
+        --max_size;
+    }
+
+    if (begin1 != end1)
+    {
+        target = std::copy(begin1, begin1 + max_size, target);
+        begin1 += max_size;
+    }
+    else
+    {
+        target = std::copy(begin2, begin2 + max_size, target);
+        begin2 += max_size;
+    }
+    return target;
+}
+
+/*!
+ * Merge routine being able to merge only the \c max_size smallest elements.
+ *
+ * The \c begin iterators are advanced accordingly, they might not reach \c end,
+ * in contrast to the usual variant.  Specially designed code should allow the
+ * compiler to generate conditional moves instead of branches.
+ *
+ * \param begin1 Begin iterator of first sequence.
+ * \param end1 End iterator of first sequence.
+ * \param begin2 Begin iterator of second sequence.
+ * \param end2 End iterator of second sequence.
+ * \param target Target begin iterator.
+ * \param max_size Maximum number of elements to merge.
+ * \param comp Comparator.
+ * \return Output end iterator.
+ */
+template <typename RandomAccessIterator1, typename RandomAccessIterator2,
+          typename OutputIterator, typename DiffType, typename Comparator>
+OutputIterator merge_advance_movc(RandomAccessIterator1& begin1,
+                                  RandomAccessIterator1 end1,
+                                  RandomAccessIterator2& begin2,
+                                  RandomAccessIterator2 end2,
+                                  OutputIterator target, DiffType max_size,
+                                  Comparator comp)
+{
+    using ValueType1 =
+        typename std::iterator_traits<RandomAccessIterator1>::value_type;
+    using ValueType2 =
+        typename std::iterator_traits<RandomAccessIterator2>::value_type;
+
+    while (begin1 != end1 && begin2 != end2 && max_size > 0)
+    {
+        RandomAccessIterator1 next1 = begin1 + 1;
+        RandomAccessIterator2 next2 = begin2 + 1;
+        ValueType1 element1 = *begin1;
+        ValueType2 element2 = *begin2;
+
+        if (comp(element2, element1))
+        {
+            element1 = element2;
+            begin2 = next2;
+        }
+        else
+        {
+            begin1 = next1;
+        }
+
+        *target = element1;
+
+        ++target;
+        --max_size;
+    }
+
+    if (begin1 != end1)
+    {
+        target = std::copy(begin1, begin1 + max_size, target);
+        begin1 += max_size;
+    }
+    else
+    {
+        target = std::copy(begin2, begin2 + max_size, target);
+        begin2 += max_size;
+    }
+
+    return target;
+}
+
+/*!
+ * Merge routine being able to merge only the \c max_size smallest elements.
+ *
+ * The \c begin iterators are advanced accordingly, they might not reach \c end,
+ * in contrast to the usual variant.  Static switch on whether to use the
+ * conditional-move variant.
+ *
+ * \param begin1 Begin iterator of first sequence.
+ * \param end1 End iterator of first sequence.
+ * \param begin2 Begin iterator of second sequence.
+ * \param end2 End iterator of second sequence.
+ * \param target Target begin iterator.
+ * \param max_size Maximum number of elements to merge.
+ * \param comp Comparator.
+ * \return Output end iterator.
+ */
+template <typename RandomAccessIterator1, typename RandomAccessIterator2,
+          typename OutputIterator, typename DiffType, typename Comparator>
+OutputIterator merge_advance(RandomAccessIterator1& begin1,
+                             RandomAccessIterator1 end1,
+                             RandomAccessIterator2& begin2,
+                             RandomAccessIterator2 end2, OutputIterator target,
+                             DiffType max_size, Comparator comp)
+{
+    return merge_advance_movc(begin1, end1, begin2, end2, target, max_size,
+                              comp);
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_MERGE_ADVANCE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * tlx/algorithm/merge_combine.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_MERGE_COMBINE_HEADER
+#define TLX_ALGORITHM_MERGE_COMBINE_HEADER
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+/*!
+ * Merge two sorted ranges and add all items comparing equal. Both ranges must
+ * be sorted using the three-way Comparator (with memcmp() semantics). Item
+ * pairs comparing equal (cmp returns 0) are combined together using a combine
+ * operator.
+ *
+ * \warning This method does not check if the ranges are sorted. Also make sure
+ * that the comparator does not work with unsigned types.
+ */
+template <typename InputIterator1, typename InputIterator2,
+          typename OutputIterator, typename Comparator,
+          typename Combine = std::plus<
+              typename std::iterator_traits<InputIterator1>::value_type> >
+OutputIterator merge_combine(InputIterator1 first1, InputIterator1 last1,
+                             InputIterator2 first2, InputIterator2 last2,
+                             OutputIterator result,
+                             Comparator cmp = Comparator(),
+                             Combine combine = Combine())
+{
+    while (true)
+    {
+        // if either range is done -> copy the rest of the other
+        if (first1 == last1)
+            return std::copy(first2, last2, result);
+        if (first2 == last2)
+            return std::copy(first1, last1, result);
+
+        // compare both items, copy or combine.
+        if (cmp(*first1, *first2) < 0)
+        {
+            *result = *first1;
+            ++first1;
+        }
+        else if (cmp(*first1, *first2) > 0)
+        {
+            *result = *first2;
+            ++first2;
+        }
+        else
+        {
+            *result = combine(*first1, *first2);
+            ++first1, ++first2;
+        }
+        ++result;
+    }
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_MERGE_COMBINE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,346 @@
+/*******************************************************************************
+ * tlx/algorithm/multisequence_partition.hpp
+ *
+ * Implementation of multisequence partition and selection.
+ *
+ * Copied and modified from STXXL, see http://stxxl.org, which itself extracted
+ * it from MCSTL http://algo2.iti.uni-karlsruhe.de/singler/mcstl/. Both are
+ * distributed under the Boost Software License, Version 1.0.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2007 Johannes Singler <singler@ira.uka.de>
+ * Copyright (C) 2014-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_ALGORITHM_MULTISEQUENCE_PARTITION_HEADER
+#define TLX_ALGORITHM_MULTISEQUENCE_PARTITION_HEADER
+
+#include <tlx/container/simple_vector.hpp>
+#include <tlx/math/round_to_power_of_two.hpp>
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <queue>
+#include <utility>
+#include <vector>
+
+namespace tlx {
+
+//! \addtogroup tlx_algorithm
+//! \{
+
+namespace multisequence_partition_detail {
+
+//! Compare a pair of types lexicographically, ascending.
+template <typename T1, typename T2, typename Comparator>
+class lexicographic
+{
+private:
+    Comparator& comp_;
+
+public:
+    explicit lexicographic(Comparator& comp) : comp_(comp)
+    {
+    }
+
+    bool operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2)
+    {
+        if (comp_(p1.first, p2.first))
+            return true;
+
+        if (comp_(p2.first, p1.first))
+            return false;
+
+        // firsts are equal
+        return p1.second < p2.second;
+    }
+};
+
+//! Compare a pair of types lexicographically, descending.
+template <typename T1, typename T2, typename Comparator>
+class lexicographic_rev
+{
+private:
+    Comparator& comp_;
+
+public:
+    explicit lexicographic_rev(Comparator& comp) : comp_(comp)
+    {
+    }
+
+    bool operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2)
+    {
+        if (comp_(p2.first, p1.first))
+            return true;
+
+        if (comp_(p1.first, p2.first))
+            return false;
+
+        // firsts are equal
+        return p2.second < p1.second;
+    }
+};
+
+} // namespace multisequence_partition_detail
+
+/*!
+ * Splits several sorted sequences at a certain global rank, resulting in a
+ * splitting point for each sequence.  The sequences are passed via a sequence
+ * of random-access iterator pairs, none of the sequences may be empty.  If
+ * there are several equal elements across the split, the ones on the left side
+ * will be chosen from sequences with smaller number.
+ *
+ * \param begin_seqs Begin of the sequence of iterator pairs.
+ * \param end_seqs End of the sequence of iterator pairs.
+ * \param rank The global rank to partition at.
+ * \param begin_offsets A random-access sequence begin where the result will be
+ * stored in. Each element of the sequence is an iterator that points to the
+ * first element on the greater part of the respective sequence.
+ * \param comp The ordering functor, defaults to std::less<T>.
+ */
+template <typename RanSeqs, typename RankType, typename RankIterator,
+          typename Comparator = std::less<
+              typename std::iterator_traits<typename std::iterator_traits<
+                  RanSeqs>::value_type::first_type>::value_type> >
+void multisequence_partition(const RanSeqs& begin_seqs, const RanSeqs& end_seqs,
+                             const RankType& rank, RankIterator begin_offsets,
+                             Comparator comp = Comparator())
+{
+    using iterator =
+        typename std::iterator_traits<RanSeqs>::value_type::first_type;
+    using diff_type = typename std::iterator_traits<iterator>::difference_type;
+    using value_type = typename std::iterator_traits<iterator>::value_type;
+
+    using SamplePair = std::pair<value_type, diff_type>;
+
+    using namespace multisequence_partition_detail;
+
+    // comparators for SamplePair
+    lexicographic<value_type, diff_type, Comparator> lcomp(comp);
+    lexicographic_rev<value_type, diff_type, Comparator> lrcomp(comp);
+
+    // number of sequences, number of elements in total (possibly including
+    // padding)
+    const diff_type m = std::distance(begin_seqs, end_seqs);
+    diff_type nmax, n;
+    RankType N = 0;
+
+    for (diff_type i = 0; i < m; ++i)
+    {
+        N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
+        assert(std::distance(begin_seqs[i].first, begin_seqs[i].second) > 0);
+    }
+
+    if (rank == N)
+    {
+        for (diff_type i = 0; i < m; ++i)
+            begin_offsets[i] = begin_seqs[i].second; // very end
+        return;
+    }
+
+    assert(m != 0 && N != 0 && rank < N);
+
+    simple_vector<diff_type> seqlen(m);
+
+    seqlen[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second);
+    nmax = seqlen[0];
+    for (diff_type i = 1; i < m; ++i)
+    {
+        seqlen[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second);
+        nmax = std::max(nmax, seqlen[i]);
+    }
+
+    // pad all lists to this length, at least as long as any ns[i], equality
+    // iff nmax = 2^k - 1
+    diff_type l = round_up_to_power_of_two(nmax + 1) - 1;
+
+    simple_vector<diff_type> a(m), b(m);
+
+    for (diff_type i = 0; i < m; ++i)
+        a[i] = 0, b[i] = l;
+
+    n = l / 2;
+
+    // invariants:
+    // 0 <= a[i] <= seqlen[i], 0 <= b[i] <= l
+
+    // initial partition
+
+    std::vector<SamplePair> sample;
+
+    for (diff_type i = 0; i < m; ++i)
+    {
+        if (n < seqlen[i])
+        {
+            // sequence long enough
+            sample.push_back(SamplePair(begin_seqs[i].first[n], i));
+        }
+    }
+
+    std::sort(sample.begin(), sample.end(), lcomp);
+
+    for (diff_type i = 0; i < m; ++i)
+    {
+        // conceptual infinity
+        if (n >= seqlen[i])
+        {
+            // sequence too short, conceptual infinity
+            sample.push_back(
+                SamplePair(begin_seqs[i].first[0] /* dummy element */, i));
+        }
+    }
+
+    size_t localrank = static_cast<size_t>(rank / l);
+
+    size_t j;
+    for (j = 0; j < localrank && ((n + 1) <= seqlen[sample[j].second]); ++j)
+        a[sample[j].second] += n + 1;
+    for (; j < static_cast<size_t>(m); ++j)
+        b[sample[j].second] -= n + 1;
+
+    // further refinement
+
+    while (n > 0)
+    {
+        n /= 2;
+
+        const value_type* lmax = nullptr; // impossible to avoid the warning?
+        for (diff_type i = 0; i < m; ++i)
+        {
+            if (a[i] > 0)
+            {
+                if (!lmax)
+                    lmax = &(begin_seqs[i].first[a[i] - 1]);
+                else
+                {
+                    // max, favor rear sequences
+                    if (!comp(begin_seqs[i].first[a[i] - 1], *lmax))
+                        lmax = &(begin_seqs[i].first[a[i] - 1]);
+                }
+            }
+        }
+
+        for (diff_type i = 0; i < m; ++i)
+        {
+            diff_type middle = (b[i] + a[i]) / 2;
+            if (lmax && middle < seqlen[i] &&
+                comp(begin_seqs[i].first[middle], *lmax))
+                a[i] = std::min(a[i] + n + 1, seqlen[i]);
+            else
+                b[i] -= n + 1;
+        }
+
+        diff_type leftsize = 0;
+        for (diff_type i = 0; i < m; ++i)
+            leftsize += a[i] / (n + 1);
+
+        diff_type skew = rank / (n + 1) - leftsize;
+
+        if (skew > 0)
+        {
+            // move to the left, find smallest
+            std::priority_queue<
+                SamplePair, std::vector<SamplePair>,
+                lexicographic_rev<value_type, diff_type, Comparator> >
+                pq(lrcomp);
+
+            for (diff_type i = 0; i < m; ++i)
+            {
+                if (b[i] < seqlen[i])
+                    pq.push(SamplePair(begin_seqs[i].first[b[i]], i));
+            }
+
+            for (; skew != 0 && !pq.empty(); --skew)
+            {
+                diff_type src = pq.top().second;
+                pq.pop();
+
+                a[src] = std::min(a[src] + n + 1, seqlen[src]);
+                b[src] += n + 1;
+
+                if (b[src] < seqlen[src])
+                    pq.push(SamplePair(begin_seqs[src].first[b[src]], src));
+            }
+        }
+        else if (skew < 0)
+        {
+            // move to the right, find greatest
+            std::priority_queue<
+                SamplePair, std::vector<SamplePair>,
+                lexicographic<value_type, diff_type, Comparator> >
+                pq(lcomp);
+
+            for (diff_type i = 0; i < m; ++i)
+            {
+                if (a[i] > 0)
+                    pq.push(SamplePair(begin_seqs[i].first[a[i] - 1], i));
+            }
+
+            for (; skew != 0; ++skew)
+            {
+                diff_type src = pq.top().second;
+                pq.pop();
+
+                a[src] -= n + 1;
+                b[src] -= n + 1;
+
+                if (a[src] > 0)
+                    pq.push(SamplePair(begin_seqs[src].first[a[src] - 1], src));
+            }
+        }
+    }
+
+    // postconditions: a[i] == b[i] in most cases, except when a[i] has been
+    // clamped because of having reached the boundary
+
+    // now return the result, calculate the offset, compare the keys on both
+    // edges of the border
+
+    // maximum of left edge, minimum of right edge
+    value_type *maxleft = nullptr, *minright = nullptr;
+    for (diff_type i = 0; i < m; ++i)
+    {
+        if (a[i] > 0)
+        {
+            if (!maxleft)
+            {
+                maxleft = &(begin_seqs[i].first[a[i] - 1]);
+            }
+            else
+            {
+                // max, favor rear sequences
+                if (!comp(begin_seqs[i].first[a[i] - 1], *maxleft))
+                    maxleft = &(begin_seqs[i].first[a[i] - 1]);
+            }
+        }
+        if (b[i] < seqlen[i])
+        {
+            if (!minright)
+            {
+                minright = &(begin_seqs[i].first[b[i]]);
+            }
+            else
+            {
+                // min, favor fore sequences
+                if (comp(begin_seqs[i].first[b[i]], *minright))
+                    minright = &(begin_seqs[i].first[b[i]]);
+            }
+        }
+    }
+
+    for (diff_type i = 0; i < m; ++i)
+        begin_offsets[i] = begin_seqs[i].first + a[i];
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_ALGORITHM_MULTISEQUENCE_PARTITION_HEADER
+
+/******************************************************************************/