code: def hilbert(x, N=None, axis=-1):
      """
      Compute the analytic signal, using the Hilbert transform.
  
      The transformation is done along the last axis by default.
  
      Parameters
      ----------
      x : array_like
          Signal data.  Must be real.
      N : int, optional
          Number of Fourier components.  Default: ``x.shape[axis]``
      axis : int, optional
          Axis along which to do the transformation.  Default: -1.
  
      Returns
      -------
      xa : ndarray
          Analytic signal of `x`, of each 1-D array along `axis`
  
      See Also
      --------
      scipy.fftpack.hilbert : Return Hilbert transform of a periodic sequence x.
  
      Notes
      -----
      The analytic signal ``x_a(t)`` of signal ``x(t)`` is:
  
      .. math:: x_a = F^{-1}(F(x) 2U) = x + i y
  
      where `F` is the Fourier transform, `U` the unit step function,
      and `y` the Hilbert transform of `x`. [1]_
  
      In other words, the negative half of the frequency spectrum is zeroed
      out, turning the real-valued signal into a complex signal.  The Hilbert
      transformed signal can be obtained from ``np.imag(hilbert(x))``, and the
      original signal from ``np.real(hilbert(x))``.
  
      Examples
      ---------
      In this example we use the Hilbert transform to determine the amplitude
      envelope and instantaneous frequency of an amplitude-modulated signal.
  
      >>> import numpy as np
      >>> import matplotlib.pyplot as plt
      >>> from scipy.signal import hilbert, chirp
  
      >>> duration = 1.0
      >>> fs = 400.0
      >>> samples = int(fs*duration)
      >>> t = np.arange(samples) / fs
  
      We create a chirp of which the frequency increases from 20 Hz to 100 Hz and
      apply an amplitude modulation.
  
      >>> signal = chirp(t, 20.0, t[-1], 100.0)
      >>> signal *= (1.0 + 0.5 * np.sin(2.0*np.pi*3.0*t) )
  
      The amplitude envelope is given by magnitude of the analytic signal. The
      instantaneous frequency can be obtained by differentiating the
      instantaneous phase in respect to time. The instantaneous phase corresponds
      to the phase angle of the analytic signal.
  
      >>> analytic_signal = hilbert(signal)
      >>> amplitude_envelope = np.abs(analytic_signal)
      >>> instantaneous_phase = np.unwrap(np.angle(analytic_signal))
      >>> instantaneous_frequency = (np.diff(instantaneous_phase) /
      ...                            (2.0*np.pi) * fs)
  
      >>> fig = plt.figure()
      >>> ax0 = fig.add_subplot(211)
      >>> ax0.plot(t, signal, label='signal')
      >>> ax0.plot(t, amplitude_envelope, label='envelope')
      >>> ax0.set_xlabel("time in seconds")
      >>> ax0.legend()
      >>> ax1 = fig.add_subplot(212)
      >>> ax1.plot(t[1:], instantaneous_frequency)
      >>> ax1.set_xlabel("time in seconds")
      >>> ax1.set_ylim(0.0, 120.0)
  
      References
      ----------
      .. [1] Wikipedia, "Analytic signal".
             https://en.wikipedia.org/wiki/Analytic_signal
      .. [2] Leon Cohen, "Time-Frequency Analysis", 1995. Chapter 2.
      .. [3] Alan V. Oppenheim, Ronald W. Schafer. Discrete-Time Signal
             Processing, Third Edition, 2009. Chapter 12.
             ISBN 13: 978-1292-02572-8
  
      """
      x = asarray(x)
      if iscomplexobj(x):
          raise ValueError("x must be real.")
      if N is None:
          N = x.shape[axis]
      if N <= 0:
          raise ValueError("N must be positive.")
  
      Xf = fftpack.fft(x, N, axis=axis)
      h = zeros(N)
      if N % 2 == 0:
          h[0] = h[N // 2] = 1
          h[1 : N // 2] = 2
      else:
          h[0] = 1
          h[1 : (N + 1) // 2] = 2
  
      if x.ndim > 1:
          ind = [newaxis] * x.ndim
          ind[axis] = slice(None)
          h = h[tuple(ind)]
      x = fftpack.ifft(Xf * h, axis=axis)
      return x
  
imports: from __future__ import division, print_function, absolute_import
  import operator
  import threading
  import sys
  import timeit
  from scipy.spatial import cKDTree
  from .None import sigtools, dlti
  from ._upfirdn import upfirdn, _output_len
  from scipy._lib.six import callable
  from scipy._lib._version import NumpyVersion
  from scipy import fftpack, linalg
  from scipy.fftpack.helper import _init_nd_shape_and_axes_sorted
  from numpy import allclose, angle, arange, argsort, array, asarray, atleast_1d, atleast_2d, cast, dot, exp, expand_dims, iscomplexobj, mean, ndarray, newaxis, ones, pi, poly, polyadd, polyder, polydiv, polymul, polysub, polyval, product, r_, ravel, real_if_close, reshape, roots, sort, take, transpose, unique, where, zeros, zeros_like
  import numpy
  import math
  from scipy.special import factorial
  from .windows import get_window
  from ._arraytools import axis_slice, axis_reverse, odd_ext, even_ext, const_ext
  from .filter_design import cheby1, _validate_sos
  from .fir_filter_design import firwin
label_desc: Use image node_id 24 for calling a global function with example usage: hilbert(x, N, axis) and returns: x