docs: def _boolrelextrema(data, comparator,
                    axis=0, order=1, mode='clip'):
      """
      Calculate the relative extrema of `data`.
  
      Relative extrema are calculated by finding locations where
      ``comparator(data[n], data[n+1:n+order+1])`` is True.
  
      Parameters
      ----------
      data : ndarray
          Array in which to find the relative extrema.
      comparator : callable
          Function to use to compare two data points.
          Should take 2 numbers as arguments.
      axis : int, optional
          Axis over which to select from `data`.  Default is 0.
      order : int, optional
          How many points on each side to use for the comparison
          to consider ``comparator(n,n+x)`` to be True.
      mode : str, optional
          How the edges of the vector are treated.  'wrap' (wrap around) or
          'clip' (treat overflow as the same as the last (or first) element).
          Default 'clip'.  See numpy.take
  
      Returns
      -------
      extrema : ndarray
          Indices of the extrema, as boolean array of same shape as data.
          True for an extrema, False else.
  
      See also
      --------
      argrelmax, argrelmin
  
      Examples
      --------
      array([False, False,  True, False, False], dtype=bool)
  
      """
      if((int(order) != order) or (order < 1)):
          raise ValueError('Order must be an int >= 1')
  
      datalen = data.shape[axis]
      locs = np.arange(0, datalen)
  
      results = np.ones(data.shape, dtype=bool)
      main = data.take(locs, axis=axis, mode=mode)
      for shift in iter(range(1, order + 1)):
          plus = data.take(locs + shift, axis=axis, mode=mode)
          minus = data.take(locs - shift, axis=axis, mode=mode)
          results &= comparator(main, plus)
          results &= comparator(main, minus)
          if(~results.any()):
              return results
      return results