code: def sosfilt(sos, x, axis=-1, zi=None):
      """
      Filter data along one dimension using cascaded second-order sections.
  
      Filter a data sequence, `x`, using a digital IIR filter defined by
      `sos`. This is implemented by performing `lfilter` for each
      second-order section.  See `lfilter` for details.
  
      Parameters
      ----------
      sos : array_like
          Array of second-order filter coefficients, must have shape
          ``(n_sections, 6)``. Each row corresponds to a second-order
          section, with the first three columns providing the numerator
          coefficients and the last three providing the denominator
          coefficients.
      x : array_like
          An N-dimensional input array.
      axis : int, optional
          The axis of the input data array along which to apply the
          linear filter. The filter is applied to each subarray along
          this axis.  Default is -1.
      zi : array_like, optional
          Initial conditions for the cascaded filter delays.  It is a (at
          least 2D) vector of shape ``(n_sections, ..., 2, ...)``, where
          ``..., 2, ...`` denotes the shape of `x`, but with ``x.shape[axis]``
          replaced by 2.  If `zi` is None or is not given then initial rest
          (i.e. all zeros) is assumed.
          Note that these initial conditions are *not* the same as the initial
          conditions given by `lfiltic` or `lfilter_zi`.
  
      Returns
      -------
      y : ndarray
          The output of the digital filter.
      zf : ndarray, optional
          If `zi` is None, this is not returned, otherwise, `zf` holds the
          final filter delay values.
  
      See Also
      --------
      zpk2sos, sos2zpk, sosfilt_zi, sosfiltfilt, sosfreqz
  
      Notes
      -----
      The filter function is implemented as a series of second-order filters
      with direct-form II transposed structure. It is designed to minimize
      numerical precision errors for high-order filters.
  
      .. versionadded:: 0.16.0
  
      Examples
      --------
      Plot a 13th-order filter's impulse response using both `lfilter` and
      `sosfilt`, showing the instability that results from trying to do a
      13th-order filter in a single stage (the numerical error pushes some poles
      outside of the unit circle):
  
      >>> import matplotlib.pyplot as plt
      >>> from scipy import signal
      >>> b, a = signal.ellip(13, 0.009, 80, 0.05, output='ba')
      >>> sos = signal.ellip(13, 0.009, 80, 0.05, output='sos')
      >>> x = signal.unit_impulse(700)
      >>> y_tf = signal.lfilter(b, a, x)
      >>> y_sos = signal.sosfilt(sos, x)
      >>> plt.plot(y_tf, 'r', label='TF')
      >>> plt.plot(y_sos, 'k', label='SOS')
      >>> plt.legend(loc='best')
      >>> plt.show()
  
      """
      x = np.asarray(x)
      sos, n_sections = _validate_sos(sos)
      use_zi = zi is not None
      if use_zi:
          zi = np.asarray(zi)
          x_zi_shape = list(x.shape)
          x_zi_shape[axis] = 2
          x_zi_shape = tuple([n_sections] + x_zi_shape)
          if zi.shape != x_zi_shape:
              raise ValueError(
                  "Invalid zi shape. With axis=%r, an input with "
                  "shape %r, and an sos array with %d sections, zi "
                  "must have shape %r, got %r."
                  % (axis, x.shape, n_sections, x_zi_shape, zi.shape)
              )
          zf = zeros_like(zi)
  
      for section in range(n_sections):
          if use_zi:
              x, zf[section] = lfilter(
                  sos[section, :3],
                  sos[section, 3:],
                  x,
                  axis,
                  zi=zi[section],
              )
          else:
              x = lfilter(sos[section, :3], sos[section, 3:], x, axis)
      out = (x, zf) if use_zi else x
      return out
  
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 41 for calling a global function with example usage: sosfilt(sos, x, axis, zi) and returns: out