treemendous 0.1.0__tar.gz

treemendous-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Joseph Cox
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

treemendous-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: treemendous
+Version: 0.1.0
+Summary: Exploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates.
+License: BSD 3-Clause License
+Author: Joseph Cox
+Author-email: joseph@codensity.io
+Requires-Python: >=3.9,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: sortedcollections (>=2.1.0,<3.0.0)
+Requires-Dist: sortedcontainers (>=2.4.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Tree-Mendous
+Exploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates.
+

treemendous-0.1.0/README.md

@@ -0,0 +1,2 @@
+# Tree-Mendous
+Exploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates.

treemendous-0.1.0/build.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+from typing import List, Dict, Any
+from pathlib import Path
+
+from pybind11.setup_helpers import Pybind11Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.dist import Distribution
+
+def build(setup_kwargs: Dict[str, Any], with_ic: bool = False) -> None:
+    compile_args = ["-O3"]
+    include_dirs = []
+    libraries = []
+    extra_link_args = []
+    
+    if with_ic:
+        compile_args.append("-DWITH_IC_MANAGER")
+        include_dirs.append("/opt/homebrew/Cellar/boost/1.86.0_2/include")
+        libraries.append("boost_system")
+        extra_link_args.append("-L/opt/homebrew/Cellar/boost/1.86.0_2/lib")
+        
+    ext_modules: List[Pybind11Extension] = [
+        Pybind11Extension(
+            "treemendous.cpp.boundary",
+            ["treemendous/cpp/boundary_bindings.cpp"],
+            cxx_std=20,
+            extra_compile_args=compile_args,
+            include_dirs=include_dirs,
+            libraries=libraries,
+            extra_link_args=extra_link_args,
+        ),
+    ]
+
+    distribution = Distribution({
+        "name": "treemendous",
+        "ext_modules": ext_modules
+    })
+
+    cmd = build_ext(distribution)
+    cmd.ensure_finalized()
+    cmd.run()
+
+    # Copy built extensions back to the project
+    for output in cmd.get_outputs():
+        output = Path(output)
+        relative_extension = output.relative_to(cmd.build_lib)
+
+        shutil.copyfile(output, relative_extension)
+        mode = os.stat(relative_extension).st_mode
+        mode |= (mode & 0o444) >> 2
+        os.chmod(relative_extension, mode)
+    # setup_kwargs.update({
+    #     "ext_modules": ext_modules,
+    #     "cmdclass": {"build_ext": build_ext},
+    # })

treemendous-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[tool.poetry]
+name = "treemendous"
+version = "0.1.0"
+description = "Exploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates."
+authors = ["Joseph Cox <joseph@codensity.io>"]
+license = "BSD 3-Clause License"
+readme = "README.md"
+
+
+
+[tool.poetry.dependencies]
+python = "^3.9"
+sortedcollections = "^2.1.0"
+sortedcontainers = "^2.4.0"
+
+[tool.poetry.group.dev.dependencies]
+sortedcontainers-stubs = "^2.4.2"
+flameprof = "^0.4"
+
+
+[tool.poetry.group.test.dependencies]
+hypothesis = "^6.119.4"
+pytest = "^8.3.3"
+
+[tool.pytest.ini_options]
+addopts = "--hypothesis-explain -vv"
+
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "pybind11>=2.13.6", "setuptools>=75.6.0"]
+# build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.build]
+script = "build.py"
+generate-setup-file = true

treemendous-0.1.0/setup.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['treemendous', 'treemendous.basic', 'treemendous.cpp']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['sortedcollections>=2.1.0,<3.0.0', 'sortedcontainers>=2.4.0,<3.0.0']
+
+setup_kwargs = {
+    'name': 'treemendous',
+    'version': '0.1.0',
+    'description': 'Exploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates.',
+    'long_description': '# Tree-Mendous\nExploring a diverse collection of interval tree implementations across multiple programming languages to identify the most efficient configurations for varied use cases, such as optimizing for query speed, memory usage, or dynamic updates.\n',
+    'author': 'Joseph Cox',
+    'author_email': 'joseph@codensity.io',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.9,<4.0',
+}
+from build import *
+build(setup_kwargs)
+
+setup(**setup_kwargs)

treemendous-0.1.0/treemendous/basic/avl.py

@@ -0,0 +1,283 @@
+from typing import Generic, Optional, List, Tuple, TypeVar, cast, overload
+from treemendous.basic.base import IntervalNodeBase, IntervalNodeProtocol, IntervalTreeBase
+
+
+
+class IntervalNode(IntervalNodeBase[IntervalNodeProtocol]):
+    def __init__(self, start: int, end: int) -> None:
+        super().__init__(start, end)
+        self.total_length: int = self.length
+        self.height: int = 1
+
+    def update_stats(self) -> None:
+        self.update_length()
+        self.total_length = self.length
+        if self.left:
+            self.total_length += self.left.total_length
+        if self.right:
+            self.total_length += self.right.total_length
+        self.height = 1 + max(
+            self.get_height(self.left), 
+            self.get_height(self.right)
+        )
+
+    @staticmethod
+    def get_height(node: Optional['IntervalNode']) -> int:
+        return node.height if node else 0
+
+R = TypeVar('R', bound=IntervalNode)
+class IntervalTree(Generic[R], IntervalTreeBase[R]):
+    def __init__(self, node_class: type[R]) -> None:
+        super().__init__()
+        self.node_class = node_class
+        self.root: Optional[R] = None
+
+    def _print_node(self, node: R, indent: str, prefix: str) -> None:
+        print(f"{indent}{prefix}{node.start}-{node.end} (len={node.length}, total_len={node.total_length})")
+
+    def release_interval(self, start: int, end: int) -> None:
+        overlapping_nodes: List[R] = []
+        self.root = self._delete_overlaps(self.root, start, end, overlapping_nodes)
+        # Merge overlapping intervals with the new interval
+        for node in overlapping_nodes:
+            start = min(start, node.start)
+            end = max(end, node.end)
+        # Insert the merged interval using the constructor
+        self.root = self._insert(self.root, self.node_class(start, end))
+
+    def reserve_interval(self, start: int, end: int) -> None:
+        self.root = self._delete_interval(self.root, start, end)
+
+    def _delete_interval(
+        self, node: Optional[R], start: int, end: int
+    ) -> Optional[R]:
+        if not node:
+            return None
+
+        if node.end <= start:
+            # Interval to delete is after the current node
+            node.right = self._delete_interval(node.right, start, end)
+        elif node.start >= end:
+            # Interval to delete is before the current node
+            node.left = self._delete_interval(node.left, start, end)
+        else:
+            # The current node overlaps with the interval to delete
+            # We may need to split the node into up to two intervals
+
+            nodes_to_insert = []
+
+            if node.start < start:
+                # Left part remains
+                left_node = self.node_class(node.start, start)
+                nodes_to_insert.append(left_node)
+
+            if node.end > end:
+                # Right part remains
+                right_node = self.node_class(end, node.end)
+                nodes_to_insert.append(right_node)
+
+            # Delete the current node and replace it with left and right parts
+            node = self._merge_subtrees(
+                self._delete_interval(node.left, start, end),
+                self._delete_interval(node.right, start, end)
+            )
+
+            # Insert any remaining parts
+            for n in nodes_to_insert:
+                node = self._insert(node, n)
+
+        if node:
+            node.update_stats()
+            node = self._rebalance(node)
+        return node
+
+    def _delete_overlaps(
+        self, node: Optional[R], start: int, end: int, overlapping_nodes: List[R]
+    ) -> Optional[R]:
+        if not node:
+            return None
+
+        if node.end <= start:
+            # No overlap, move to the right
+            node.right = self._delete_overlaps(node.right, start, end, overlapping_nodes)
+        elif node.start >= end:
+            # No overlap, move to the left
+            node.left = self._delete_overlaps(node.left, start, end, overlapping_nodes)
+        else:
+            # Overlap detected
+            overlapping_nodes.append(node)
+            # Remove this node and continue searching in both subtrees
+            node = self._merge_subtrees(
+                self._delete_overlaps(node.left, start, end, overlapping_nodes),
+                self._delete_overlaps(node.right, start, end, overlapping_nodes)
+            )
+            return node
+
+        if node:
+            node.update_stats()
+            node = self._rebalance(node)
+        return node
+
+    def _merge_subtrees(
+        self, left: Optional[R], right: Optional[R]
+    ) -> Optional[R]:
+        if not left:
+            return right
+        if not right:
+            return left
+
+        # Find the node with the minimum start in the right subtree
+        min_node = self._get_min(right)
+        right = self._delete_min(right)
+        min_node.left = left
+        min_node.right = right
+        min_node.update_stats()
+        return self._rebalance(min_node)
+
+    def _delete_min(self, node: R) -> Optional[R]:
+        if node.left is None:
+            return node.right
+        node.left = self._delete_min(node.left)
+        node.update_stats()
+        return self._rebalance(node)
+
+    def _insert(self, node: Optional[R], new_node: R) -> R:
+        if not node:
+            return new_node
+
+        if new_node.start < node.start:
+            node.left = self._insert(node.left, new_node)
+        else:
+            node.right = self._insert(node.right, new_node)
+
+        node.update_stats()
+        node = self._rebalance(node)
+        return node
+
+    def _get_min(self, node: IntervalNode) -> IntervalNode:
+        current = node
+        while current.left:
+            current = current.left
+        return current
+
+    def _rebalance(self, node: R) -> R:
+        balance = self._get_balance(node)
+        if balance > 1:
+            # Left heavy
+            if self._get_balance(node.left) < 0:
+                # Left-Right case
+                node.left = self._rotate_left(node.left)
+            # Left-Left case
+            node = self._rotate_right(node)
+        elif balance < -1:
+            # Right heavy
+            if self._get_balance(node.right) > 0:
+                # Right-Left case
+                node.right = self._rotate_right(node.right)
+            # Right-Right case
+            node = self._rotate_left(node)
+        return node
+
+    def _get_balance(self, node: Optional[IntervalNode]) -> int:
+        if not node:
+            return 0
+        return IntervalNode.get_height(node.left) - IntervalNode.get_height(node.right)
+
+    @overload
+    def _rotate_left(self, z: None) -> None: ...
+
+    @overload
+    def _rotate_left(self, z: R) -> R: ...
+
+    def _rotate_left(self, z: Optional[R]) -> Optional[R]:
+        if not z or not z.right:
+            return z
+        y: R = z.right
+        subtree: Optional[R] = y.left
+
+        # Perform rotation
+        y.left = z
+        z.right = subtree
+
+        # Update heights and stats
+        z.update_stats()
+        y.update_stats()
+        return y
+
+    @overload
+    def _rotate_right(self, z: None) -> None: ...
+
+    @overload
+    def _rotate_right(self, z: R) -> R: ...
+
+    def _rotate_right(self, z: Optional[R]) -> Optional[R]:
+        if not z or not z.left:
+            return z
+        y: R = z.left
+        subtree: Optional[R] = y.right
+
+        # Perform rotation
+        y.right = z
+        z.left = subtree
+
+        # Update heights and stats
+        z.update_stats()
+        y.update_stats()
+        return y
+    
+    def get_intervals(self) -> List[Tuple[int, int]]:
+        intervals: List[Tuple[int, int]] = []
+        self._get_intervals(self.root, intervals)
+        return intervals
+
+    def _get_intervals(self, node: Optional[R], intervals: List[Tuple[int, int]]) -> None:
+        if not node:
+            return
+        intervals.append((node.start, node.end))
+        self._get_intervals(node.left, intervals)
+        self._get_intervals(node.right, intervals)
+
+# Example usage:
+if __name__ == "__main__":
+    tree = IntervalTree[IntervalNode](IntervalNode)
+    # Initially, the whole interval [0, 100] is available
+    tree.release_interval(0, 100)
+    print("Initial tree:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [0, 1
+    tree.reserve_interval(0, 1)
+    print("\nAfter scheduling [0, 1]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Unschedule interval [0, 1]
+    tree.release_interval(0, 1)
+    print("\nAfter unscheduling [0, 1]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [10, 20]
+    tree.reserve_interval(10, 20)
+    print("\nAfter scheduling [10, 20]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [30, 40]
+    tree.reserve_interval(30, 40)
+    print("\nAfter scheduling [30, 40]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Unschedule interval [10, 20]
+    tree.release_interval(10, 20)
+    print("\nAfter unscheduling [10, 20]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Split at pivot 50 (delete [50, 50])
+    tree.reserve_interval(50, 50)
+    print("\nAfter splitting at pivot 50:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")

treemendous-0.1.0/treemendous/basic/avl_earliest.py

@@ -0,0 +1,127 @@
+from typing import Optional
+
+from treemendous.basic.base import IntervalNodeProtocol
+from treemendous.basic.avl import IntervalNode, IntervalTree
+
+class EarliestIntervalNode(IntervalNode, IntervalNodeProtocol):
+    def __init__(self, start: int, end: int) -> None:
+        super().__init__(start, end)
+        self.min_start: int = start
+        self.max_end: int = end
+        self.max_length: int = end - start
+
+    def update_stats(self) -> None:
+        super().update_stats()
+        
+        self.min_start = self.start
+        self.max_end = self.end
+        self.max_length = self.end - self.start
+
+        if self.left:
+            assert isinstance(self.left, EarliestIntervalNode)
+            self.min_start = min(self.min_start, self.left.min_start)
+            self.max_end = max(self.max_end, self.left.max_end)
+            self.max_length = max(self.max_length, self.left.max_length)
+        if self.right:
+            assert isinstance(self.right, EarliestIntervalNode)
+            self.min_start = min(self.min_start, self.right.min_start)
+            self.max_end = max(self.max_end, self.right.max_end)
+            self.max_length = max(self.max_length, self.right.max_length)
+
+class EarliestIntervalTree(IntervalTree[EarliestIntervalNode]):
+    def __init__(self) -> None:
+        super().__init__(EarliestIntervalNode)
+
+    def _print_node(self, node: EarliestIntervalNode, indent: str, prefix: str) -> None:
+        print(f"{indent}{prefix}{node.start}-{node.end} "
+              f"(min_start={node.min_start}, max_end={node.max_end}, max_length={node.max_length})")
+
+    def find_interval(self, point: int, length: int) -> Optional[EarliestIntervalNode]:
+        return self._find_interval(self.root, point, length)
+
+    def _find_interval(self, node: Optional[EarliestIntervalNode], point: int, 
+                      length: int) -> Optional[EarliestIntervalNode]:
+        if not node:
+            return None
+        if node.start >= point and (node.end - node.start) >= length:
+            # Potential candidate
+            left_candidate = self._find_interval(node.left, point, length)
+            return left_candidate if left_candidate else node
+        elif node.start < point:
+            # Search right subtree
+            return self._find_interval(node.right, point, length)
+        else:
+            # Node's interval is too short; search right subtree
+            return self._find_interval(node.right, point, length)
+
+    def _insert(self, node: Optional[EarliestIntervalNode], 
+                new_node: EarliestIntervalNode) -> EarliestIntervalNode:
+        node = super()._insert(node, new_node)
+        node.update_stats()  # Update the earliest-specific stats
+        return node
+
+
+# Example usage:
+if __name__ == "__main__":
+    tree = EarliestIntervalTree()
+    # Initially, the whole interval [0, 100) is available
+    tree.release_interval(0, 100)
+    print("Initial tree:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [0, 1
+    tree.reserve_interval(0, 1)
+    print("\nAfter scheduling [0, 1]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Unschedule interval [0, 1]
+    tree.release_interval(0, 1)
+    print("\nAfter unscheduling [0, 1]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [1, 2]
+    tree.reserve_interval(1, 3)
+    print("\nAfter scheduling [1, 3]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [2, 3]
+    tree.reserve_interval(2, 5)
+    print("\nAfter scheduling [2, 5]:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+
+    # Schedule interval [10, 20)
+    tree.reserve_interval(10, 20)
+    print("\nAfter scheduling [10, 20):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [15, 25)
+    tree.reserve_interval(15, 25)
+    print("\nAfter scheduling [15, 25):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Find interval starting at or after 18 with length at least 5
+    result = tree.find_interval(18, 5)
+    if result:
+        print(f"\nFound interval: [{result.start}, {result.end})")
+    else:
+        print("\nNo suitable interval found.")
+
+    # Unschedule interval [10, 20)
+    tree.release_interval(10, 20)
+    print("\nAfter unscheduling [10, 20):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Delete interval overlapping multiple intervals
+    tree.reserve_interval(5, 15)
+    print("\nAfter deleting interval [5, 15):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")

treemendous-0.1.0/treemendous/basic/base.py

@@ -0,0 +1,76 @@
+from abc import ABC, abstractmethod
+from typing import Generic, List, Optional, Tuple, TypeVar, Protocol
+
+class IntervalNodeProtocol(Protocol):
+    start: int
+    end: int
+    length: int
+    height: int
+    total_length: int
+    left: Optional['IntervalNodeProtocol']
+    right: Optional['IntervalNodeProtocol']
+    
+    def update_stats(self) -> None: ...
+    def update_length(self) -> None: ...
+
+T = TypeVar('T', bound=IntervalNodeProtocol)
+
+class IntervalNodeBase(Generic[T]):
+    def __init__(self, start: int, end: int) -> None:
+        self.start: int = start
+        self.end: int = end
+        self.length: int = end - start
+        self._height: int = 1
+        self._total_length: int = self.length
+
+        self.left: Optional[T] = None
+        self.right: Optional[T] = None
+
+    @property
+    @abstractmethod
+    def height(self) -> int:
+        return self._height
+
+    @height.setter 
+    def height(self, value: int) -> None:
+        self._height = value
+
+    @property
+    @abstractmethod
+    def total_length(self) -> int:
+        return self._total_length
+
+    @total_length.setter 
+    def total_length(self, value: int) -> None:
+        self._total_length = value
+
+    def update_length(self) -> None:
+        self.length = self.end - self.start
+
+
+class IntervalTreeBase(Generic[T], ABC):
+    def __init__(self, root: Optional[T] = None) -> None:
+        self.root: Optional[T] = root
+
+    def print_tree(self) -> None:
+        self._print_tree(self.root)
+
+    def _print_tree(self, node: Optional[T], indent: str = "", prefix: str = "") -> None:
+        if node is None:
+            return
+            
+        self._print_tree(node.right, indent + "    ", "┌── ")  # type: ignore
+        self._print_node(node, indent, prefix)
+        self._print_tree(node.left, indent + "    ", "└── ")   # type: ignore
+
+    def get_total_available_length(self) -> int:
+        if not self.root:
+            return 0
+        return self.root.total_length
+
+    @abstractmethod
+    def _print_node(self, node: T, indent: str, prefix: str) -> None: ...
+
+    @abstractmethod
+    def get_intervals(self) -> List[Tuple[int, int]]: ...
+

treemendous-0.1.0/treemendous/basic/boundary.py

@@ -0,0 +1,171 @@
+from sortedcontainers import SortedDict
+from typing import List, Optional, Tuple
+
+class IntervalManager:
+    def __init__(self) -> None:
+        # Intervals are stored as {start: end}
+        self.intervals: SortedDict[int, int] = SortedDict()
+        self.total_available_length: int = 0
+
+    def release_interval(self, start: int, end: int) -> None:
+        if start >= end:
+            return
+
+        # Find position to insert or merge
+        idx = self.intervals.bisect_left(start)
+
+        # Check and merge with previous interval if overlapping or adjacent
+        if idx > 0:
+            prev_start = self.intervals.keys()[idx - 1]
+            prev_end = self.intervals[prev_start]
+            if prev_end >= start:
+                start = prev_start
+                end = max(end, prev_end)
+                idx -= 1
+                del self.intervals[prev_start]
+                self.total_available_length -= prev_end - prev_start
+
+        # Merge with next intervals if overlapping
+        while idx < len(self.intervals):
+            curr_start = self.intervals.keys()[idx]
+            curr_end = self.intervals[curr_start]
+            if curr_start > end:
+                break
+            end = max(end, curr_end)
+            del self.intervals[curr_start]
+            self.total_available_length -= curr_end - curr_start
+
+        # Insert the new merged interval
+        self.intervals[start] = end
+        self.total_available_length += end - start
+
+    def reserve_interval(self, start: int, end: int) -> None:
+        if start >= end:
+            return
+
+        idx = self.intervals.bisect_left(start)
+
+        if idx > 0:
+            prev_start = self.intervals.keys()[idx - 1]
+            prev_end = self.intervals[prev_start]
+            if prev_end > start:
+                idx -= 1
+
+        intervals_to_add: List[Tuple[int, int]] = []
+        keys_to_delete: List[int] = []
+
+        while idx < len(self.intervals):
+            curr_start = self.intervals.keys()[idx]
+            curr_end = self.intervals[curr_start]
+
+            if curr_start >= end:
+                break
+
+            overlap_start = max(start, curr_start)
+            overlap_end = min(end, curr_end)
+
+            if overlap_start < overlap_end:
+                # Mark current interval for removal
+                keys_to_delete.append(curr_start)
+                self.total_available_length -= curr_end - curr_start
+
+                # Add non-overlapping intervals
+                if curr_start < start:
+                    intervals_to_add.append((curr_start, start))
+                if curr_end > end:
+                    intervals_to_add.append((end, curr_end))
+
+            idx += 1
+
+        # Remove intervals after iteration
+        for key in keys_to_delete:
+            del self.intervals[key]
+
+        # Add new intervals
+        for s, e in intervals_to_add:
+            self.intervals[s] = e
+            self.total_available_length += e - s
+
+    def find_interval(self, point: int, length: int) -> Optional[Tuple[int, int]]:
+        idx = self.intervals.bisect_left(point)
+        intervals_keys = self.intervals.keys()
+
+        # Check the interval at idx
+        if idx < len(intervals_keys):
+            s = intervals_keys[idx]
+            e = self.intervals[s]
+            if s <= point < e and e - point >= length:
+                return point, point + length
+            elif s > point and e - s >= length:
+                return s, s + length
+
+        # Check the previous interval
+        if idx > 0:
+            idx -= 1
+            s = intervals_keys[idx]
+            e = self.intervals[s]
+            if s <= point < e and e - point >= length:
+                return point, point + length
+            elif point < s and e - s >= length:
+                return s, s + length
+
+        return None
+
+    def get_total_available_length(self) -> int:
+        return self.total_available_length
+
+    def print_intervals(self) -> None:
+        print("Available intervals:")
+        for s, e in self.intervals.items():
+            print(f"[{s}, {e})")
+        print(f"Total available length: {self.total_available_length}")
+    
+    def get_intervals(self) -> List[Tuple[int, int]]:
+        return list(self.intervals.items())
+
+# Example usage:
+if __name__ == "__main__":
+    manager = IntervalManager()
+    # Initially, the whole interval [0, 100) is available
+    manager.release_interval(0, 100)
+    print("Initial intervals:")
+    manager.print_intervals()
+
+    # Schedule interval [10, 20)
+    manager.reserve_interval(10, 20)
+    print("\nAfter scheduling [10, 20):")
+    manager.print_intervals()
+
+    # Schedule interval [15, 25)
+    manager.reserve_interval(15, 25)
+    print("\nAfter scheduling [15, 25):")
+    manager.print_intervals()
+
+    # Unschedule interval [10, 20)
+    manager.release_interval(10, 20)
+    print("\nAfter unscheduling [10, 20):")
+    manager.print_intervals()
+
+    # Schedule two adjacent intervals [30, 40) and [40, 50)
+    manager.reserve_interval(30, 40)
+    manager.reserve_interval(40, 50)
+    print("\nAfter scheduling two adjacent intervals [30, 40) and [40, 50):")
+    manager.print_intervals()
+
+    # Release overlapping interval [35, 45)
+    manager.release_interval(35, 45)
+    print("\nAfter releasing overlapping interval [35, 45):")
+    manager.print_intervals()
+
+    # Test finding intervals
+    result = manager.find_interval(0, 15)
+    print(f"\nFinding interval of length 15 starting from 0: {result}")
+
+    # Test complete overlap
+    manager.reserve_interval(60, 80)
+    print("\nAfter reserving [60, 80):")
+    manager.print_intervals()
+    
+    manager.release_interval(65, 75)
+    print("\nAfter releasing internal interval [65, 75):")
+    manager.print_intervals()

treemendous-0.1.0/treemendous/basic/segment.py

@@ -0,0 +1,100 @@
+from typing import Optional
+from base import IntervalNodeBase, IntervalTreeBase
+
+
+class SegmentTreeNode(IntervalNodeBase['SegmentTreeNode']):
+    def __init__(self, start: int, end: int) -> None:
+        super().__init__(start, end)
+        self.total_length: int = self.length
+        self.is_full: bool = True
+
+    def update_node(self) -> None:
+        if self.left is not None and self.right is not None:
+            self.total_length = self.left.total_length + self.right.total_length
+            self.is_full = self.left.is_full and self.right.is_full
+        else:
+            self.total_length = self.length if self.is_full else 0
+
+class SegmentTree(IntervalTreeBase[SegmentTreeNode]):
+    def __init__(self, start: int, end: int) -> None:
+        super().__init__(SegmentTreeNode(start, end))
+
+    def _print_node(self, node: SegmentTreeNode, indent: str, prefix: str) -> None:
+        print(f"{indent}{prefix}{node.start}-{node.end} (len={node.length}, total_len={node.total_length}, is_full={node.is_full})")
+
+    def _build(self, node: SegmentTreeNode | None) -> None:
+        if node is None:
+            return
+        if node.end - node.start <= 1:
+            return
+        mid: int = (node.start + node.end) // 2
+        node.left = SegmentTreeNode(node.start, mid)
+        node.right = SegmentTreeNode(mid, node.end)
+        self._build(node.left)
+        self._build(node.right)
+
+    def build(self) -> None:
+        self._build(self.root)
+
+    def _update(self, node: Optional[SegmentTreeNode], start: int, end: int, is_full: bool) -> None:
+        if node is None:
+            return
+        if node.end <= start or node.start >= end:
+            return
+        if node.start >= start and node.end <= end:
+            node.is_full = is_full
+            node.total_length = node.length if is_full else 0
+            node.left = None
+            node.right = None
+        else:
+            if node.left is None or node.right is None:
+                mid: int = (node.start + node.end) // 2
+                node.left = SegmentTreeNode(node.start, mid)
+                node.right = SegmentTreeNode(mid, node.end)
+                node.left.is_full = node.right.is_full = node.is_full
+                node.left.total_length = (node.left.end - node.left.start) if node.left.is_full else 0
+                node.right.total_length = (node.right.end - node.right.start) if node.right.is_full else 0
+            self._update(node.left, start, end, is_full)
+            self._update(node.right, start, end, is_full)
+            node.update_node()
+
+    def schedule_interval(self, start: int, end: int) -> None:
+        self._update(self.root, start, end, False)
+
+    def unschedule_interval(self, start: int, end: int) -> None:
+        self._update(self.root, start, end, True)
+    
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Initialize segment tree with interval [0, 100)
+    tree = SegmentTree(0, 100)
+    tree.build()
+    print("Initial tree:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [10, 20)
+    tree.schedule_interval(10, 20)
+    print("\nAfter scheduling [10, 20):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Schedule interval [30, 40)
+    tree.schedule_interval(30, 40)
+    print("\nAfter scheduling [30, 40):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Unschedule interval [10, 20)
+    tree.unschedule_interval(10, 20)
+    print("\nAfter unscheduling [10, 20):")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")
+
+    # Split at pivot 50 (schedule [50, 50))
+    tree.schedule_interval(50, 50)
+    print("\nAfter splitting at pivot 50:")
+    tree.print_tree()
+    print(f"Total available length: {tree.get_total_available_length()}")

treemendous-0.1.0/treemendous/cpp/boundary.cpp

@@ -0,0 +1,129 @@
+// IntervalManager class implementation
+#include <map>
+#include <vector>
+#include <optional>
+#include <iostream>
+
+class IntervalManager {
+public:
+    IntervalManager() : total_available_length(0) {}
+
+    void release_interval(int start, int end) {
+        if (start >= end) return;
+
+        auto it = intervals.lower_bound(start);
+
+        // Merge with previous interval if overlapping or adjacent
+        if (it != intervals.begin()) {
+            auto prev_it = std::prev(it);
+            if (prev_it->second >= start) {
+                start = prev_it->first;
+                end = std::max(end, prev_it->second);
+                total_available_length -= prev_it->second - prev_it->first;
+                intervals.erase(prev_it);
+            }
+        }
+
+        // Merge with overlapping intervals
+        while (it != intervals.end() && it->first <= end) {
+            end = std::max(end, it->second);
+            total_available_length -= it->second - it->first;
+            it = intervals.erase(it);
+        }
+
+        intervals[start] = end;
+        total_available_length += end - start;
+    }
+
+    void reserve_interval(int start, int end) {
+        if (start >= end) return;
+
+        auto it = intervals.lower_bound(start);
+
+        if (it != intervals.begin()) {
+            auto prev_it = std::prev(it);
+            if (prev_it->second > start) {
+                it = prev_it;
+            }
+        }
+
+        std::vector<std::map<int, int>::iterator> to_erase;
+        std::vector<std::pair<int, int>> to_add;
+
+        while (it != intervals.end() && it->first < end) {
+            int curr_start = it->first;
+            int curr_end = it->second;
+
+            int overlap_start = std::max(start, curr_start);
+            int overlap_end = std::min(end, curr_end);
+
+            if (overlap_start < overlap_end) {
+                to_erase.push_back(it);
+                total_available_length -= curr_end - curr_start;
+
+                if (curr_start < start) {
+                    to_add.emplace_back(curr_start, start);
+                }
+                if (curr_end > end) {
+                    to_add.emplace_back(end, curr_end);
+                }
+            }
+            ++it;
+        }
+
+        for (auto& eit : to_erase) {
+            intervals.erase(eit);
+        }
+        for (const auto& interval : to_add) {
+            intervals[interval.first] = interval.second;
+            total_available_length += interval.second - interval.first;
+        }
+    }
+
+    std::optional<std::pair<int, int>> find_interval(int point, int length) {
+        auto it = intervals.lower_bound(point);
+
+        if (it != intervals.end()) {
+            int s = it->first;
+            int e = it->second;
+            if (s <= point && e - point >= length) {
+                return std::make_pair(point, point + length);
+            } else if (s > point && e - s >= length) {
+                return std::make_pair(s, s + length);
+            }
+        }
+
+        if (it != intervals.begin()) {
+            --it;
+            int s = it->first;
+            int e = it->second;
+            if (s <= point && e - point >= length) {
+                return std::make_pair(point, point + length);
+            } else if (point < s && e - s >= length) {
+                return std::make_pair(s, s + length);
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    int get_total_available_length() const {
+        return total_available_length;
+    }
+    void print_intervals() const {
+        std::ostream& out = std::cout;
+        out << "Available intervals:\n";
+        for (const auto& [s, e] : intervals) {
+            out << "[" << s << ", " << e << ")\n";
+        }
+        out << "Total available length: " << total_available_length << "\n";
+    }
+
+    std::vector<std::pair<int, int>> get_intervals() const {
+        return std::vector<std::pair<int, int>>(intervals.begin(), intervals.end());
+    }
+
+private:
+    std::map<int, int> intervals;
+    int total_available_length;
+};

treemendous-0.1.0/treemendous/cpp/boundary_bindings.cpp

@@ -0,0 +1,31 @@
+// Pybind11 bindings for IntervalManager
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#ifdef WITH_IC_MANAGER
+#include "boundary_ic.cpp"  // Include the IntervalManager implementation
+#endif
+#include "boundary.cpp"  // Include the IntervalManager implementation
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(boundary, m) {
+    py::class_<IntervalManager>(m, "IntervalManager")
+        .def(py::init<>())
+        .def("release_interval", &IntervalManager::release_interval)
+        .def("reserve_interval", &IntervalManager::reserve_interval)
+        .def("find_interval", &IntervalManager::find_interval)
+        .def("get_total_available_length", &IntervalManager::get_total_available_length)
+        .def("print_intervals", &IntervalManager::print_intervals)
+        .def("get_intervals", &IntervalManager::get_intervals);
+
+#ifdef WITH_IC_MANAGER
+    py::class_<ICIntervalManager>(m, "ICIntervalManager")
+        .def(py::init<>())
+        .def("release_interval", &ICIntervalManager::release_interval)
+        .def("reserve_interval", &ICIntervalManager::reserve_interval)
+        .def("find_interval", &ICIntervalManager::find_interval)
+        .def("get_total_available_length", &ICIntervalManager::get_total_available_length)
+        .def("print_intervals", &ICIntervalManager::print_intervals)
+        .def("get_intervals", &ICIntervalManager::get_intervals);
+#endif
+}

treemendous-0.1.0/treemendous/cpp/boundary_ic.cpp

@@ -0,0 +1,65 @@
+// IntervalManager class implementation using Boost Interval Containers
+#include <boost/icl/interval_set.hpp>
+#include <boost/icl/interval.hpp>
+#include <iostream>
+#include <vector>
+#include <optional>
+
+class ICIntervalManager {
+public:
+    ICIntervalManager() : total_available_length(0) {}
+
+    void release_interval(int start, int end) {
+        if (start >= end) return;
+        auto interval = boost::icl::interval<int>::right_open(start, end);
+
+        intervals.add(interval);
+
+        total_available_length = intervals.size();
+    }
+
+    void reserve_interval(int start, int end) {
+        if (start >= end) return;
+        auto interval = boost::icl::interval<int>::right_open(start, end);
+
+        intervals.subtract(interval);
+
+        total_available_length = intervals.size();
+    }
+
+    std::optional<std::pair<int, int>> find_interval(int point, int length) {
+        auto it = intervals.find(point);
+        if (it != intervals.end()) {
+            int s = it->lower();
+            int e = it->upper();
+            if (e - point >= length) {
+                return std::make_pair(point, point + length);
+            }
+        }
+        return std::nullopt;
+    }
+
+    int get_total_available_length() const {
+        return total_available_length;
+    }
+
+    void print_intervals() const {
+        std::cout << "Available intervals:\n";
+        for (const auto& interval : intervals) {
+            std::cout << "[" << interval.lower() << ", " << interval.upper() << ")\n";
+        }
+        std::cout << "Total available length: " << total_available_length << "\n";
+    }
+
+    std::vector<std::pair<int, int>> get_intervals() const {
+        std::vector<std::pair<int, int>> result;
+        for (const auto& interval : intervals) {
+            result.emplace_back(interval.lower(), interval.upper());
+        }
+        return result;
+    }
+
+private:
+    boost::icl::interval_set<int> intervals;
+    int total_available_length;
+};