docs: def filter_bandpass_fourier(t, data, method='stft', detrend='linear',
                              df=None, harm=True,
                              df_out=None, harm_out=True):
      """ Return bandpass FFT-filtered signal (and the rest)
  
      Optionnally include all higher harmonics
      Can also exclude a frequency interval and its higher harmonics
  
      Parameters
      ----------
      t :         np.ndarray
          1D array, monotonously increasing time vector with regular spacing
      data :      np.ndarray
          1 or 2D array, with shape[0]=t.size, the data to be filtered
      method:     str
          Flag indicating which method to use:
              - 'rfft':   scipy.fftpack.rfft
              - 'stft':   scipy.signal.stft
      df :        None / list
          List or tuple of len()=2, containing the bandpass lower / upper bounds
      harm :      bool
          If True all the higher harmonics of df will also be included
      df_out :    None / list
          List or tuple of len()=2, containing the bandpass lower / upper bounds
          to be excluded from filtering (if it overlaps with high harmonics of df)
      harm_out :  bool
          If True, the higher harmonics of the interval df_out are also excluded
      Test :      bool
          If True tests all the input arguments for any mistake
  
      Returns
      -------
      In :        np.ndarray
          Array with shape=data.shape, filtered signal retrieved from inverse FFT
      Out :       np.ndarray
          Array with shape=data.shape, excluded signal from filtering
  
      """
      # Check / format inputs
      assert data.ndim==2 and t.ndim==1
      assert data.shape[0]==(t.size,)
      assert np.allclose(t,np.unique(t)) and np.std(np.diff(t))<=1.e-12
      assert method in ['rfft','stft']
      lC = [df is None, df_out is None]
      assert np.sum(lC)<=1, "At least one of df or df_out must be provided !"
      assert type(harm) is bool and type(harm_out) is bool
      if df is not None:
          df = np.unique(df)
          assert df.shape==(2,)
      if df_out is not None:
          df_out = np.unique(df_out)
          assert df_out.shape==(2,)
  
      nt, nch = data.shape
      dt = np.mean(np.diff(t))
      fs = 1./dt
  
      if method=='rfft':
          data_in, data_out = _filter_bandpass_rfft(data, t, dt, fs, nt, nch,
                                                    df=df, harm=harm,
                                                    df_out=df_out,
                                                    harm_out=harm_out)
      elif methd=='stft':
          data_in, data_out = _filter_bandpass_stft(data, t, dt, fs, nt, nch,
                                                    df=df, harm=harm,
                                                    df_out=df_out,
                                                    harm_out=harm_out)