WIP: blabla

Author: 5cript

drawings/example_drawings.hpp

@@ -2,7 +2,9 @@
 
 #include <interval-tree/draw.hpp>
 
+#include <random>
 #include <string>
+#include <iostream>
 
 static void drawDocExample()
 {
@@ -31,7 +33,7 @@ static void drawFromTests1()
 
     interval_tree_t<int> tree;
 
-    std::vector <interval_tree_t<int>::interval_type> intervalCollection;
+    std::vector<interval_tree_t<int>::interval_type> intervalCollection;
 
     intervalCollection.push_back({-51, 11});
     intervalCollection.push_back({26, 68});
@@ -67,8 +69,39 @@ static void drawFromTests1()
     drawTree("drawings/from_tests_1_deoverlapped.png", tree, false, false);
 }
 
+static void drawLargeOverlapFree()
+{
+    using namespace lib_interval_tree;
+
+    interval_tree_t<int> tree;
+
+    for (int i = 0; i < 30; ++i)
+    {
+        tree.insert({i * 10, i * 10 + 5});
+    }
+
+    drawTree("drawings/large_overlap_free.png", tree, false, false);
+
+    std::vector<std::pair<int, int>> intervals;
+    for (int i = 0; i < 30; ++i)
+    {
+        intervals.emplace_back(i * 10, i * 10 + 5);
+    }
+
+    // insert shuffled into new tree
+    interval_tree_t<int> tree2;
+    std::mt19937 rng(std::random_device{}());
+    std::shuffle(intervals.begin(), intervals.end(), rng);
+    for (const auto& interval : intervals)
+    {
+        tree2.insert({interval.first, interval.second});
+    }
+    drawTree("drawings/large_overlap_free_shuffled.png", tree2, false, false);
+}
+
 static void drawAll()
 {
     drawDocExample();
     drawFromTests1();
+    drawLargeOverlapFree();
 }

include/interval-tree/interval_tree.hpp

@@ -10,6 +10,7 @@
 #include <stdexcept>
 #include <iterator>
 #include <type_traits>
+#include <cassert>
 
 namespace lib_interval_tree
 {
@@ -218,21 +219,19 @@ namespace lib_interval_tree
          */
         slice_type<interval> extrude(interval const& other) const
         {
-            if (!overlaps(other))
-                return {};
-
             slice_type<interval> slices{};
             if (low_ < other.low_)
             {
-                auto slice = interval{low_, interval_kind::left_slice_upper_bound(other.low_)};
+                auto slice = interval{low_, std::min(interval_kind::left_slice_upper_bound(other.low_), high_)};
                 // >= comparison avoids overflows in case of unsigned integers
                 if (slice.high_ >= slice.low_ && slice.size() > 0)
                     slices.left_slice = std::move(slice);
             }
             // low_ == other.low_ does not produce a left slice in any case.
-            if (other.high_ > high_)
+            if (high_ > other.high_)
             {
-                auto slice = interval{interval_kind::right_slice_lower_bound(high_), other.high_};
+                // FIXME: think: is the max violating edge conditions?
+                auto slice = interval{std::max(interval_kind::right_slice_lower_bound(other.high_), low_), high_};
                 // >= comparison avoids overflows in case of unsigned integers
                 if (slice.high_ >= slice.low_ && slice.size() > 0)
                     slices.right_slice = std::move(slice);
@@ -376,15 +375,25 @@ namespace lib_interval_tree
             slice_type<interval> slices{};
             if (low_ < other.low_)
             {
-                auto slice = interval{low_, interval_kind::left_slice_upper_bound(other.low_, other.left_border())};
+                auto slice = interval{
+                    low_,
+                    std::min(other.low_, high_),
+                    left_border_,
+                    other.left_border() == interval_border::open ? interval_border::closed : interval_border::open
+                };
                 // >= comparison avoids overflows in case of unsigned integers
                 if (slice.high_ >= slice.low_ && slice.size() > 0)
                     slices.left_slice = std::move(slice);
             }
             // low_ == other.low_ does not produce a left slice in any case.
-            if (other.high_ > high_)
+            if (high_ > other.high_)
             {
-                auto slice = interval{interval_kind::right_slice_lower_bound(high_, right_border_), other.high_};
+                auto slice = interval{
+                    std::max(other.high_, low_),
+                    high_,
+                    right_border_ == interval_border::open ? interval_border::closed : interval_border::open,
+                    other.right_border()
+                };
                 // >= comparison avoids overflows in case of unsigned integers
                 if (slice.high_ >= slice.low_ && slice.size() > 0)
                     slices.right_slice = std::move(slice);
@@ -1415,12 +1424,13 @@ namespace lib_interval_tree
 
         // TODO: private
         /**
-         * @brief Finds the first interval that is right of the given value and does not contain it.
+         * @brief Finds the interval that is right of the given value and does not contain it.
+         * Only works with deoverlapped trees.
          *
          * @param low
          * @return node_type*
          */
-        node_type* find_first_not_right_of_i(value_type search_value) const
+        node_type* find_directly_right_of_i(value_type search_value) const
         {
             if (empty())
                 return nullptr;
@@ -1458,18 +1468,62 @@ namespace lib_interval_tree
             if (is_interval_strictly_right_of_value(node))
                 return node;
 
-            // We only end up when node == root_, otherwise we never went down the tree to begin with.
+            // We only end up here when node == root_, otherwise we never went down the tree to begin with.
             return nullptr;
         }
 
+        /**
+         * @brief Find the interval that is left of the given value or contains it.
+         * Only works in deoverlapped trees. Because a deoverlapped tree is indistinguishable
+         * from a regular binary search tree. The tree is then also sorted by the upper interval bound.
+         * Making this search possible in the first place.
+         *
+         * @param search_value
+         * @return node_type*
+         */
+        node_type* find_leftest_interval_of_value_i(value_type search_value) const
+        {
+            if (empty())
+                return nullptr;
+
+            auto* node = root_;
+
+            // low of a node is always lower than the lows of all nodes right of that node
+            // high of a node is always lower than the lows of all nodes right of that node
+
+            bool go_left = false;
+            bool go_right = false;
+
+            do
+            {
+                go_right = search_value > node->high();
+                if (go_right)
+                {
+                    go_right &= node->right_ != nullptr;
+                    if (go_right)
+                        node = node->right_;
+                    continue;
+                }
+
+                go_left = node->left_ != nullptr && search_value < node->low();
+                if (go_left)
+                    node = node->left_;
+            } while (go_left || go_right);
+
+            if (search_value < node->low())
+                return nullptr;
+
+            return node;
+        }
+
         /**
          * Only works with deoverlapped trees.
          * Removes all intervals from the given interval and produces a tree that contains the remaining intervals.
          * This is basically the other punch overload with ival = [tree_lowest, tree_highest]
          *
          * @param ival The range in which to punch out the gaps as a new tree
          */
-        interval_tree punch(interval_type const& ival) const
+        interval_tree punch(interval_type ival) const
         {
             interval_tree result;
 
@@ -1480,57 +1534,48 @@ namespace lib_interval_tree
                 return result;
             }
 
-            auto* first_not_right = find_first_not_right_of_i(ival.low());
-            if (first_not_right == nullptr)
+            auto* left_of_or_contains = find_leftest_interval_of_value_i(ival.low());
+
+            const_iterator iter{nullptr, this};
+            if (left_of_or_contains == nullptr)
             {
-                // [LAST] [ival]
-                // or
-                // [LAST]
-                //    [ival]
-                // or
-                // [ LAST ]
-                // [ival]
-
-                auto last = crbegin();
-                if (!ival.overlaps(*last))
+                iter = cbegin();
+                // not adjacent or overlapping?
+                if (ival.high() < iter->low())
                 {
-                    // [LAST] [ival]
-                    // ival is fully right of the tree, so just return a tree with this interval:
                     result.insert(ival);
                     return result;
                 }
-
-                const auto slices = last->extrude(ival);
-                if (slices.right_slice)
-                    result.insert(std::move(slices.right_slice).value());
             }
             else
             {
-                // // There is an interval left of or inside ival.
-
-                // const auto low = [&]() {
-                //     if (first_not_right->interval()->overlap(ival))
-                //     {
-                //         const auto joined = ival.join(*first_not_right->interval()).high();
-                //         return joined.high() + (joined.within(joined.high()) ? 1 : 0);
-                //     }
-                //     else
-                //     {
-                //         return ival.low();
-                //     }
-                // }();
-
-                // auto next = increment({first_not_right});
-
-                // if (next == end())
-                // {
-                //     value_type high = next->low() - (next->interval()->within(next->low() - 1));
-                // }
-                // else
-                // {
-                //     // TODO:
-                // }
+                iter = const_iterator{left_of_or_contains, this};
             }
+
+            slice_type<interval_type> ex;
+            bool insert_remaining = false;
+            for (; iter != cend(); ++iter)
+            {
+                ex = ival.extrude(*iter);
+                if (ex.left_slice)
+                    result.insert(*ex.left_slice);
+
+                if (ex.right_slice)
+                {
+                    ival = std::move(*ex.right_slice);
+                    // TODO: Can I avoid assigning this every loop? -> maybe by extracting the first iteration?
+                    insert_remaining = true;
+                }
+                else
+                {
+                    insert_remaining = false;
+                    break;
+                }
+            }
+
+            if (insert_remaining && ival.size() > 0)
+                result.insert(ival);
+
             return result;
         }