Queries

def at(self, p):
    """
    Get all intervals containing point p.
    
    Parameters:
    - p: Point to query (any comparable type)
    
    Returns:
    set: Set of intervals where begin <= p < end
    
    Time Complexity: O(m + log n) where m is result size
    """

def overlaps_point(self, p):
    """
    Test if any interval contains point p.
    
    Parameters:
    - p: Point to test
    
    Returns:
    bool: True if any interval contains p
    
    Time Complexity: O(log n)
    """

def overlap(self, begin, end=None):
    """
    Get all intervals overlapping with range or interval.
    
    Parameters:
    - begin: Range start or Interval object
    - end: Range end (optional if begin is Interval)
    
    Returns:
    set: Set of intervals that overlap with [begin, end)
    
    Time Complexity: O(m + k*log n) where m is result size, k is complexity factor
    """

def envelop(self, begin, end=None):
    """
    Get all intervals completely contained within range.
    
    Parameters:
    - begin: Range start or Interval object  
    - end: Range end (optional if begin is Interval)
    
    Returns:
    set: Set of intervals completely within [begin, end)
    
    Time Complexity: O(m + k*log n) where m is result size, k is complexity factor
    """

def overlaps(self, begin, end=None):
    """
    Test if any interval overlaps with range or point.
    
    Parameters:
    - begin: Range start, point, or Interval object
    - end: Range end (optional)
    
    Returns:
    bool: True if any interval overlaps
    
    Time Complexity: O(r*log n) where r is complexity factor
    """

def overlaps_range(self, begin, end):
    """
    Test if any interval overlaps with range [begin, end).
    
    Parameters:
    - begin: Range start
    - end: Range end
    
    Returns:
    bool: True if any interval overlaps with range
    
    Time Complexity: O(r*log n) where r is complexity factor
    """

def __getitem__(self, index):
    """
    Query intervals using slice notation.
    
    Parameters:
    - index: Point (for point query) or slice object (for range query)
    
    Returns:
    set: Set of overlapping intervals
    
    Usage:
    - tree[point] -> intervals containing point
    - tree[start:stop] -> intervals overlapping [start, stop)
    
    Time Complexity: O(k*log(n) + m) where m is result size, k is complexity factor
    """

def __contains__(self, item):
    """
    Test if exact interval exists in tree.
    
    Parameters:
    - item: Interval object to test
    
    Returns:
    bool: True if exact interval (including data) exists in tree
    
    Time Complexity: O(1)
    """

def containsi(self, begin, end, data=None):
    """
    Test if interval with specific begin/end/data exists.
    
    Parameters:
    - begin: Lower bound
    - end: Upper bound
    - data: Data payload
    
    Returns:
    bool: True if exact interval exists in tree
    
    Time Complexity: O(1)
    """

from intervaltree import Interval, IntervalTree

# Create tree with some intervals
tree = IntervalTree([
    Interval(0, 10, "first"),
    Interval(5, 15, "second"), 
    Interval(20, 30, "third")
])

# Find all intervals containing point 7
overlapping = tree.at(7)
print(overlapping)  # {Interval(0, 10, 'first'), Interval(5, 15, 'second')}

# Using slice notation (equivalent to tree.at(7))
overlapping = tree[7]
print(overlapping)  # Same result

# Test if any interval contains point
if tree.overlaps_point(7):
    print("Point 7 is covered")

if tree.overlaps_point(50):
    print("Point 50 is covered")  # Won't print - no intervals contain 50

from intervaltree import Interval, IntervalTree

tree = IntervalTree([
    Interval(0, 10, "first"),
    Interval(5, 15, "second"),
    Interval(12, 18, "third"),
    Interval(20, 30, "fourth")
])

# Find intervals overlapping with range [8, 14)
overlapping = tree.overlap(8, 14)
print(overlapping)  # {Interval(0, 10, 'first'), Interval(5, 15, 'second'), Interval(12, 18, 'third')}

# Using slice notation (equivalent)
overlapping = tree[8:14]
print(overlapping)  # Same result

# Find intervals completely contained within [6, 16)
contained = tree.envelop(6, 16)
print(contained)  # {Interval(12, 18, 'third')} - only this one is fully contained

# Test if any interval overlaps with range
if tree.overlaps(8, 14):
    print("Range [8, 14) has overlapping intervals")

if tree.overlaps_range(25, 35):
    print("Range [25, 35) has overlapping intervals")

from intervaltree import Interval, IntervalTree

tree = IntervalTree([
    Interval(0, 10, "first"),
    Interval(15, 25, "second"),
    Interval(30, 40, "third")
])

# Query using another interval
query_interval = Interval(5, 20)

# Find overlapping intervals
overlapping = tree.overlap(query_interval)
print(overlapping)  # {Interval(0, 10, 'first'), Interval(15, 25, 'second')}

# Find contained intervals  
contained = tree.envelop(query_interval)
print(contained)  # set() - no intervals fully contained in [5, 20)

# Test overlap with interval
if tree.overlaps(query_interval):
    print("Query interval overlaps with tree intervals")

from intervaltree import Interval, IntervalTree

tree = IntervalTree([
    Interval(0, 10, "data1"),
    Interval(15, 25, "data2")
])

# Test for exact interval presence
test_interval = Interval(0, 10, "data1")
if test_interval in tree:
    print("Exact interval found")

# Test with different data (won't match)
test_interval2 = Interval(0, 10, "different_data")
if test_interval2 not in tree:
    print("Interval with different data not found")

# Test using values
if tree.containsi(0, 10, "data1"):
    print("Interval (0, 10, 'data1') exists")

if not tree.containsi(0, 10, "data3"):
    print("Interval (0, 10, 'data3') does not exist")

from intervaltree import Interval, IntervalTree

# Create tree with overlapping intervals
tree = IntervalTree([
    Interval(0, 20, "big_interval"),
    Interval(5, 10, "small1"),
    Interval(12, 15, "small2"),
    Interval(25, 35, "separate")
])

# Find all intervals that might affect processing in range [8, 16)
affected = tree.overlap(8, 16)
print(f"Intervals affected by range [8, 16): {len(affected)}")

# Find intervals completely within a processing window
window_start, window_end = 3, 18
contained = tree.envelop(window_start, window_end)
print(f"Intervals fully contained in window: {len(contained)}")

# Check if a point is in a "gap" (not covered by any interval)
test_point = 22
if not tree.overlaps_point(test_point):
    print(f"Point {test_point} is in a gap")

# Find all intervals that would be partially processed
all_overlapping = tree.overlap(8, 16)
fully_contained = tree.envelop(8, 16)
partially_overlapping = all_overlapping - fully_contained
print(f"Partially overlapping intervals: {len(partially_overlapping)}")