Checking Non-Overlapping and Monotonic Intervals in pandas.IntervalArray

Functionality

• This property checks whether an IntervalArray in Pandas meets two conditions:
  • Non-overlapping
    No two intervals share any points (endpoints). In simpler terms, there are no gaps or overlaps between the intervals.
  • Monotonic
    The intervals are either consistently increasing in value (left endpoints getting larger) or consistently decreasing (left endpoints getting smaller).

Return Value

• The property returns True if both conditions (non-overlapping and monotonic) are satisfied, and False otherwise.

Purpose

• This property is useful for analyzing ordered sequences of intervals in Pandas. It helps you determine if the intervals are well-defined and suitable for certain operations that require non-overlapping or monotonic behavior.

Example

import pandas as pd

# Create a non-overlapping, monotonically increasing IntervalArray
intervals = pd.IntervalArray.from_tuples([(1, 3), (4, 7), (8, 10)])

# Check if the IntervalArray is non-overlapping and monotonic
result = intervals.is_non_overlapping_monotonic
print(result)  # Output: True

# Example of a non-monotonic IntervalArray
non_monotonic_intervals = pd.IntervalArray.from_tuples([(5, 8), (2, 4), (9, 11)])
result = non_monotonic_intervals.is_non_overlapping_monotonic
print(result)  # Output: False (not monotonic)

# Example of an overlapping IntervalArray
overlapping_intervals = pd.IntervalArray.from_tuples([(1, 4), (3, 6)])
result = overlapping_intervals.is_non_overlapping_monotonic
print(result)  # Output: False (overlapping)

• This property is a convenient way to check these conditions without manually iterating through the intervals.
• Operations involving IntervalArray objects often require them to be non-overlapping and/or monotonic for accurate results.
• The IntervalArray data type in Pandas is specifically designed for representing intervals with closed endpoints on the same side (left-closed, right-closed by default).

---

Handling Overlaps

import pandas as pd

overlapping_intervals = pd.IntervalArray.from_tuples([(1, 4), (3, 6)])

# Check if the intervals are overlapping
result = overlapping_intervals.is_non_overlapping_monotonic
print(result)  # Output: False (overlapping intervals)

# Create a new non-overlapping IntervalArray from the original one
non_overlapping_intervals = overlapping_intervals.difference(overlapping_intervals[1:])

# Check if the new IntervalArray is non-overlapping and monotonic
result = non_overlapping_intervals.is_non_overlapping_monotonic
print(result)  # Output: True (non-overlapping after difference)

This example shows how to identify overlapping intervals and create a new non-overlapping version using set operations.

Handling Non-Monotonicity

import pandas as pd

non_monotonic_intervals = pd.IntervalArray.from_tuples([(5, 8), (2, 4), (9, 11)])

# Check if the intervals are monotonic
result = non_monotonic_intervals.is_non_overlapping_monotonic
print(result)  # Output: False (not monotonic)

# Sort the IntervalArray to achieve monotonicity
sorted_intervals = non_monotonic_intervals.sort_values()

# Check if the sorted IntervalArray is non-overlapping and monotonic
result = sorted_intervals.is_non_overlapping_monotonic
print(result)  # Output: True (monotonic after sorting)

This example demonstrates how to sort an IntervalArray to achieve monotonicity, which might be necessary for certain operations.

Conditional Operations Based on Monotonicity

import pandas as pd

intervals = pd.IntervalArray.from_tuples([(1, 3), (4, 7), (8, 10)])

if intervals.is_non_overlapping_monotonic:
    # Perform operations that require non-overlapping and monotonic intervals
    print("Intervals are suitable for further analysis.")
else:
    print("Intervals need to be adjusted (e.g., remove overlaps, sort) before proceeding.")

This example shows how you can use is_non_overlapping_monotonic to conditionally perform operations based on the characteristics of the IntervalArray.

---

Separate Checks for Non-Overlapping and Monotonic

You can achieve the same functionality by checking for non-overlapping and monotonic behavior separately:

import pandas as pd

def is_non_overlapping(intervals):
  # Check if any interval overlaps with its subsequent neighbor
  for i in range(len(intervals) - 1):
    if intervals[i].right > intervals[i + 1].left:
      return False
  return True

def is_monotonic(intervals):
  # Check if the intervals are consistently increasing or decreasing
  increasing = intervals[1:].left >= intervals[:-1].left
  decreasing = intervals[1:].left <= intervals[:-1].left
  return increasing.all() or decreasing.all()

intervals = pd.IntervalArray.from_tuples([(1, 3), (4, 7), (8, 10)])

non_overlapping = is_non_overlapping(intervals)
monotonic = is_monotonic(intervals)

if non_overlapping and monotonic:
  print("Intervals are non-overlapping and monotonic.")

This approach offers more control over the checks and might be useful if you need to perform additional custom logic based on the individual properties.

Looping Through Intervals

For a simpler approach, you can iterate through the intervals and compare adjacent ones:

import pandas as pd

intervals = pd.IntervalArray.from_tuples([(1, 3), (4, 7), (8, 10)])

non_overlapping = True
monotonic = True
for i in range(len(intervals) - 1):
  if intervals[i].right > intervals[i + 1].left:
    non_overlapping = False
    break  # Exit loop if overlap is found
  if not (intervals[i].left <= intervals[i + 1].left):  # Check for both increasing and decreasing
    monotonic = False
    break

if non_overlapping and monotonic:
  print("Intervals are non-overlapping and monotonic.")

This is a more basic approach that might be suitable for smaller datasets but can be less efficient for larger ones.

• For very large datasets, separate checks or looping might not be the most efficient options.
• If you want more control over the checks or need to perform additional logic, consider separate checks or looping.
• If you need a concise and built-in solution, pandas.arrays.IntervalArray.is_non_overlapping_monotonic is the best choice.