code: def __match_intervals(
      intervals_from: np.ndarray,
      intervals_to: np.ndarray,
      strict: bool = True,
  ) -> np.ndarray:  # pragma: no cover
      """Numba-accelerated interval matching algorithm."""
      # sort index of the interval starts
      start_index = np.argsort(intervals_to[:, 0])
  
      # sort index of the interval ends
      end_index = np.argsort(intervals_to[:, 1])
  
      # and sorted values of starts
      start_sorted = intervals_to[start_index, 0]
      # and ends
      end_sorted = intervals_to[end_index, 1]
  
      search_ends = np.searchsorted(
          start_sorted, intervals_from[:, 1], side="right"
      )
      search_starts = np.searchsorted(
          end_sorted, intervals_from[:, 0], side="left"
      )
  
      output = np.empty(len(intervals_from), dtype=numba.uint32)
      for i in range(len(intervals_from)):
          query = intervals_from[i]
  
          # Find the intervals that start after our query ends
          after_query = search_ends[i]
          # And the intervals that end after our query begins
          before_query = search_starts[i]
  
          # Candidates for overlapping have to (end after we start) and (begin before we end)
          candidates = set(start_index[:after_query]) & set(
              end_index[before_query:]
          )
  
          # Proceed as before
          if len(candidates) > 0:
              output[i] = __match_interval_overlaps(
                  query, intervals_to, candidates
              )
          elif strict:
              # Numba only lets us use compile-time constants in exception messages
              raise ParameterError
          else:
              # Find the closest interval
              # (start_index[after_query] - query[1]) is the distance to the next interval
              # (query[0] - end_index[before_query])
              dist_before = np.inf
              dist_after = np.inf
              if search_starts[i] > 0:
                  dist_before = (
                      query[0] - end_sorted[search_starts[i] - 1]
                  )
              if search_ends[i] + 1 < len(intervals_to):
                  dist_after = (
                      start_sorted[search_ends[i] + 1] - query[1]
                  )
              if dist_before < dist_after:
                  output[i] = end_index[search_starts[i] - 1]
              else:
                  output[i] = start_index[search_ends[i] + 1]
      return output
  
file_path: librosa/librosa/util/matching.py
imports: import numpy
  import numba
  from .exceptions import ParameterError
  from .utils import valid_intervals
  from .._typing import _SequenceLike
label_desc: Use image node_id 3 for calling a global function with example usage: __match_intervals(intervals_from, intervals_to, strict) and returns: output