#### Previous topic

scipy.signal.symiirorder2

#### Next topic

scipy.signal.lfiltic

# scipy.signal.lfilter

`scipy.signal.``lfilter`(b, a, x, axis=-1, zi=None)

  Filter data along one-dimension with an IIR or FIR filter.

  Filter a data sequence, x, using a digital filter. This works for many fundamental data types (including Object type). The filter is a direct form II transposed implementation of the standard difference equation (see Notes).

  Parameters:

  b : array_like

  > The numerator coefficient vector in a 1-D sequence.

  a : array_like

  > The denominator coefficient vector in a 1-D sequence. If `a[0]` is not 1, then both a and b are normalized by `a[0]`.

  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 filter delays. It is a vector (or array of vectors for an N-dimensional input) of length `max(len(a),len(b))-1`. If zi is None or is not given then initial rest is assumed. See `lfiltic` for more information.

  Returns:

  y : array

  > The output of the digital filter.

  zf : array, optional

  > If zi is None, this is not returned, otherwise, zf holds the final filter delay values.

  Notes

  The filter function is implemented as a direct II transposed structure. This means that the filter implements:

      a[0]*y[n] = b[0]*x[n] + b[1]*x[n-1] + ... + b[nb]*x[n-nb]
                              - a[1]*y[n-1] - ... - a[na]*y[n-na]

  using the following difference equations:

      y[m] = b[0]*x[m] + z[0,m-1]
      z[0,m] = b[1]*x[m] + z[1,m-1] - a[1]*y[m]
      ...
      z[n-3,m] = b[n-2]*x[m] + z[n-2,m-1] - a[n-2]*y[m]
      z[n-2,m] = b[n-1]*x[m] - a[n-1]*y[m]

  where m is the output sample number and n=max(len(a),len(b)) is the model order.

  The rational transfer function describing this filter in the z-transform domain is:

                          -1               -nb
              b[0] + b[1]z  + ... + b[nb] z
      Y(z) = ---------------------------------- X(z)
                          -1               -na
              a[0] + a[1]z  + ... + a[na] z