code: def tfr_array_multitaper(
      data,
      sfreq,
      freqs,
      n_cycles=7.0,
      zero_mean=True,
      time_bandwidth=4.0,
      use_fft=True,
      decim=1,
      output="complex",
      n_jobs=None,
      *,
      verbose=None,
      epoch_data=None,
  ):
      """Compute Time-Frequency Representation (TFR) using DPSS tapers.
  
      Same computation as `~mne.time_frequency.tfr_multitaper`, but operates on
      :class:`NumPy arrays <numpy.ndarray>` instead of `~mne.Epochs` or
      `~mne.Evoked` objects.
  
      Parameters
      ----------
      data : array of shape (n_epochs, n_channels, n_times)
          The epochs.
      sfreq : float
          Sampling frequency of the data in Hz.
      %(freqs_tfr)s
      %(n_cycles_tfr)s
      zero_mean : bool
          If True, make sure the wavelets have a mean of zero. Defaults to True.
      %(time_bandwidth_tfr)s
      use_fft : bool
          Use the FFT for convolutions or not. Defaults to True.
      %(decim_tfr)s
      output : str, default 'complex'
  
          * ``'complex'`` : single trial per taper complex values.
          * ``'power'`` : single trial power.
          * ``'phase'`` : single trial per taper phase.
          * ``'avg_power'`` : average of single trial power.
          * ``'itc'`` : inter-trial coherence.
          * ``'avg_power_itc'`` : average of single trial power and inter-trial
            coherence across trials.
      %(n_jobs)s
      %(verbose)s
      epoch_data : None
          Deprecated parameter for providing epoched data as of 1.7, will be replaced with
          the ``data`` parameter in 1.8. New code should use the ``data`` parameter. If
          ``epoch_data`` is not ``None``, a warning will be raised.
  
      Returns
      -------
      out : array
          Time frequency transform of ``data``.
  
          - if ``output in ('complex',' 'phase')``, array of shape
            ``(n_epochs, n_chans, n_tapers, n_freqs, n_times)``
          - if ``output`` is ``'power'``, array of shape ``(n_epochs, n_chans,
            n_freqs, n_times)``
          - else, array of shape ``(n_chans, n_freqs, n_times)``
  
          If ``output`` is ``'avg_power_itc'``, the real values in ``out``
          contain the average power and the imaginary values contain the
          inter-trial coherence: :math:`out = power_{avg} + i * ITC`.
  
      See Also
      --------
      mne.time_frequency.tfr_multitaper
      mne.time_frequency.tfr_morlet
      mne.time_frequency.tfr_array_morlet
      mne.time_frequency.tfr_stockwell
      mne.time_frequency.tfr_array_stockwell
  
      Notes
      -----
      %(temporal_window_tfr_intro)s
      %(temporal_window_tfr_multitaper_notes)s
      %(time_bandwidth_tfr_notes)s
  
      .. versionadded:: 0.14.0
      """
      from .tfr import _compute_tfr
  
      if epoch_data is not None:
          warn(
              "The parameter for providing data will be switched from `epoch_data` to "
              "`data` in 1.8. Use the `data` parameter to avoid this warning.",
              FutureWarning,
          )
  
      return _compute_tfr(
          data,
          freqs,
          sfreq=sfreq,
          method="multitaper",
          n_cycles=n_cycles,
          zero_mean=zero_mean,
          time_bandwidth=time_bandwidth,
          use_fft=use_fft,
          decim=decim,
          output=output,
          n_jobs=n_jobs,
          verbose=verbose,
      )
  
file_path: mne-python/mne/time_frequency/multitaper.py
imports: import numpy
  from scipy.fft import rfft, rfftfreq
  from scipy.integrate import trapezoid
  from scipy.signal import get_window
  from scipy.signal.windows import dpss
  from ..parallel import parallel_func
  from ..utils import _check_option, logger, verbose, warn
label_desc: Use image node_id 8 for calling a global function with example usage: tfr_array_multitaper(data, sfreq, freqs, n_cycles, zero_mean, time_bandwidth, use_fft, decim, output, n_jobs) and returns: _compute_tfr