code: def chirp(t, f0, t1, f1, method="linear", phi=0, vertex_zero=True):
      """Frequency-swept cosine generator.
  
      In the following, 'Hz' should be interpreted as 'cycles per unit';
      there is no requirement here that the unit is one second.  The
      important distinction is that the units of rotation are cycles, not
      radians. Likewise, `t` could be a measurement of space instead of time.
  
      Parameters
      ----------
      t : array_like
          Times at which to evaluate the waveform.
      f0 : float
          Frequency (e.g. Hz) at time t=0.
      t1 : float
          Time at which `f1` is specified.
      f1 : float
          Frequency (e.g. Hz) of the waveform at time `t1`.
      method : {'linear', 'quadratic', 'logarithmic', 'hyperbolic'}, optional
          Kind of frequency sweep.  If not given, `linear` is assumed.  See
          Notes below for more details.
      phi : float, optional
          Phase offset, in degrees. Default is 0.
      vertex_zero : bool, optional
          This parameter is only used when `method` is 'quadratic'.
          It determines whether the vertex of the parabola that is the graph
          of the frequency is at t=0 or t=t1.
  
      Returns
      -------
      y : ndarray
          A numpy array containing the signal evaluated at `t` with the
          requested time-varying frequency.  More precisely, the function
          returns ``cos(phase + (pi/180)*phi)`` where `phase` is the integral
          (from 0 to `t`) of ``2*pi*f(t)``. ``f(t)`` is defined below.
  
      See Also
      --------
      sweep_poly
  
      Notes
      -----
      There are four options for the `method`.  The following formulas give
      the instantaneous frequency (in Hz) of the signal generated by
      `chirp()`.  For convenience, the shorter names shown below may also be
      used.
  
      linear, lin, li:
  
          ``f(t) = f0 + (f1 - f0) * t / t1``
  
      quadratic, quad, q:
  
          The graph of the frequency f(t) is a parabola through (0, f0) and
          (t1, f1).  By default, the vertex of the parabola is at (0, f0).
          If `vertex_zero` is False, then the vertex is at (t1, f1).  The
          formula is:
  
          if vertex_zero is True:
  
              ``f(t) = f0 + (f1 - f0) * t**2 / t1**2``
  
          else:
  
              ``f(t) = f1 - (f1 - f0) * (t1 - t)**2 / t1**2``
  
          To use a more general quadratic function, or an arbitrary
          polynomial, use the function `scipy.signal.waveforms.sweep_poly`.
  
      logarithmic, log, lo:
  
          ``f(t) = f0 * (f1/f0)**(t/t1)``
  
          f0 and f1 must be nonzero and have the same sign.
  
          This signal is also known as a geometric or exponential chirp.
  
      hyperbolic, hyp:
  
          ``f(t) = f0*f1*t1 / ((f0 - f1)*t + f1*t1)``
  
          f0 and f1 must be nonzero.
  
      Examples
      --------
      The following will be used in the examples:
  
      >>> from scipy.signal import chirp, spectrogram
      >>> import matplotlib.pyplot as plt
  
      For the first example, we'll plot the waveform for a linear chirp
      from 6 Hz to 1 Hz over 10 seconds:
  
      >>> t = np.linspace(0, 10, 5001)
      >>> w = chirp(t, f0=6, f1=1, t1=10, method='linear')
      >>> plt.plot(t, w)
      >>> plt.title("Linear Chirp, f(0)=6, f(10)=1")
      >>> plt.xlabel('t (sec)')
      >>> plt.show()
  
      For the remaining examples, we'll use higher frequency ranges,
      and demonstrate the result using `scipy.signal.spectrogram`.
      We'll use a 10 second interval sampled at 8000 Hz.
  
      >>> fs = 8000
      >>> T = 10
      >>> t = np.linspace(0, T, T*fs, endpoint=False)
  
      Quadratic chirp from 1500 Hz to 250 Hz over 10 seconds
      (vertex of the parabolic curve of the frequency is at t=0):
  
      >>> w = chirp(t, f0=1500, f1=250, t1=10, method='quadratic')
      >>> ff, tt, Sxx = spectrogram(w, fs=fs, noverlap=256, nperseg=512,
      ...                           nfft=2048)
      >>> plt.pcolormesh(tt, ff[:513], Sxx[:513], cmap='gray_r')
      >>> plt.title('Quadratic Chirp, f(0)=1500, f(10)=250')
      >>> plt.xlabel('t (sec)')
      >>> plt.ylabel('Frequency (Hz)')
      >>> plt.grid()
      >>> plt.show()
  
      Quadratic chirp from 1500 Hz to 250 Hz over 10 seconds
      (vertex of the parabolic curve of the frequency is at t=10):
  
      >>> w = chirp(t, f0=1500, f1=250, t1=10, method='quadratic',
      ...           vertex_zero=False)
      >>> ff, tt, Sxx = spectrogram(w, fs=fs, noverlap=256, nperseg=512,
      ...                           nfft=2048)
      >>> plt.pcolormesh(tt, ff[:513], Sxx[:513], cmap='gray_r')
      >>> plt.title('Quadratic Chirp, f(0)=1500, f(10)=250\\n' +
      ...           '(vertex_zero=False)')
      >>> plt.xlabel('t (sec)')
      >>> plt.ylabel('Frequency (Hz)')
      >>> plt.grid()
      >>> plt.show()
  
      Logarithmic chirp from 1500 Hz to 250 Hz over 10 seconds:
  
      >>> w = chirp(t, f0=1500, f1=250, t1=10, method='logarithmic')
      >>> ff, tt, Sxx = spectrogram(w, fs=fs, noverlap=256, nperseg=512,
      ...                           nfft=2048)
      >>> plt.pcolormesh(tt, ff[:513], Sxx[:513], cmap='gray_r')
      >>> plt.title('Logarithmic Chirp, f(0)=1500, f(10)=250')
      >>> plt.xlabel('t (sec)')
      >>> plt.ylabel('Frequency (Hz)')
      >>> plt.grid()
      >>> plt.show()
  
      Hyperbolic chirp from 1500 Hz to 250 Hz over 10 seconds:
  
      >>> w = chirp(t, f0=1500, f1=250, t1=10, method='hyperbolic')
      >>> ff, tt, Sxx = spectrogram(w, fs=fs, noverlap=256, nperseg=512,
      ...                           nfft=2048)
      >>> plt.pcolormesh(tt, ff[:513], Sxx[:513], cmap='gray_r')
      >>> plt.title('Hyperbolic Chirp, f(0)=1500, f(10)=250')
      >>> plt.xlabel('t (sec)')
      >>> plt.ylabel('Frequency (Hz)')
      >>> plt.grid()
      >>> plt.show()
  
      """
      # 'phase' is computed in _chirp_phase, to make testing easier.
      phase = _chirp_phase(t, f0, t1, f1, method, vertex_zero)
      # Convert  phi to radians.
      phi *= pi / 180
      return cos(phase + phi)
  
file_path: catboost/contrib/python/scipy/py2/scipy/signal/waveforms.py
imports: from __future__ import division, print_function, absolute_import
  import numpy
  from numpy import asarray, zeros, place, nan, mod, pi, extract, log, sqrt, exp, cos, sin, polyval, polyint
  from scipy._lib.six import string_types
label_desc: Use image node_id 4 for calling a global function with example usage: chirp(t, f0, t1, f1, method, phi, vertex_zero) and returns: cos