code: def tukey(M, alpha=0.5, sym=True):
      r"""Return a Tukey window, also known as a tapered cosine window.
  
      Parameters
      ----------
      M : int
          Number of points in the output window. If zero or less, an empty
          array is returned.
      alpha : float, optional
          Shape parameter of the Tukey window, representing the fraction of the
          window inside the cosine tapered region.
          If zero, the Tukey window is equivalent to a rectangular window.
          If one, the Tukey window is equivalent to a Hann window.
      sym : bool, optional
          When True (default), generates a symmetric window, for use in filter
          design.
          When False, generates a periodic window, for use in spectral analysis.
  
      Returns
      -------
      w : ndarray
          The window, with the maximum value normalized to 1 (though the value 1
          does not appear if `M` is even and `sym` is True).
  
      References
      ----------
      .. [1] Harris, Fredric J. (Jan 1978). "On the use of Windows for Harmonic
             Analysis with the Discrete Fourier Transform". Proceedings of the
             IEEE 66 (1): 51-83. :doi:`10.1109/PROC.1978.10837`
      .. [2] Wikipedia, "Window function",
             https://en.wikipedia.org/wiki/Window_function#Tukey_window
  
      Examples
      --------
      Plot the window and its frequency response:
  
      >>> from scipy import signal
      >>> from scipy.fftpack import fft, fftshift
      >>> import matplotlib.pyplot as plt
  
      >>> window = signal.tukey(51)
      >>> plt.plot(window)
      >>> plt.title("Tukey window")
      >>> plt.ylabel("Amplitude")
      >>> plt.xlabel("Sample")
      >>> plt.ylim([0, 1.1])
  
      >>> plt.figure()
      >>> A = fft(window, 2048) / (len(window)/2.0)
      >>> freq = np.linspace(-0.5, 0.5, len(A))
      >>> response = 20 * np.log10(np.abs(fftshift(A / abs(A).max())))
      >>> plt.plot(freq, response)
      >>> plt.axis([-0.5, 0.5, -120, 0])
      >>> plt.title("Frequency response of the Tukey window")
      >>> plt.ylabel("Normalized magnitude [dB]")
      >>> plt.xlabel("Normalized frequency [cycles per sample]")
  
      """
      if _len_guards(M):
          return np.ones(M)
  
      if alpha <= 0:
          return np.ones(M, "d")
      elif alpha >= 1.0:
          return hann(M, sym=sym)
  
      M, needs_trunc = _extend(M, sym)
  
      n = np.arange(0, M)
      width = int(np.floor(alpha * (M - 1) / 2.0))
      n1 = n[0 : width + 1]
      n2 = n[width + 1 : M - width - 1]
      n3 = n[M - width - 1 :]
  
      w1 = 0.5 * (1 + np.cos(np.pi * (-1 + 2.0 * n1 / alpha / (M - 1))))
      w2 = np.ones(n2.shape)
      w3 = 0.5 * (
          1
          + np.cos(
              np.pi * (-2.0 / alpha + 1 + 2.0 * n3 / alpha / (M - 1))
          )
      )
  
      w = np.concatenate((w1, w2, w3))
  
      return _truncate(w, needs_trunc)
  
imports: from __future__ import division, print_function, absolute_import
  import operator
  import warnings
  import numpy
  from scipy import fftpack, linalg, special
  from scipy._lib.six import string_types
label_desc: Use image node_id 16 for calling a global function with example usage: tukey(M, alpha, sym) and returns: _truncate, np, np, hann