Linear Time Invariant system class in transfer function form.

Represents the system as the continuous-time transfer function :math:`H(s)=\sum_=0^N bN-i s^i / \sum_j=0^M aM-j s^j` or the discrete-time transfer function :math:`H(s)=\sum_=0^N bN-i z^i / \sum_j=0^M aM-j z^j`, where :math:`b` are elements of the numerator `num`, :math:`a` are elements of the denominator `den`, and ``N == len(b) - 1``, ``M == len(a) - 1``. `TransferFunction` systems inherit additional functionality from the `lti`, respectively the `dlti` classes, depending on which system representation is used.

Parameters ---------- *system: arguments The `TransferFunction` class can be instantiated with 1 or 2 arguments. The following gives the number of input arguments and their interpretation:

* 1: `lti` or `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 2: array_like: (numerator, denominator) dt: float, optional Sampling time s of the discrete-time systems. Defaults to `None` (continuous-time). Must be specified as a keyword argument, for example, ``dt=0.1``.

See Also -------- ZerosPolesGain, StateSpace, lti, dlti tf2ss, tf2zpk, tf2sos

Notes ----- Changing the value of properties that are not part of the `TransferFunction` system representation (such as the `A`, `B`, `C`, `D` state-space matrices) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_ss()`` before accessing/changing the A, B, C, D system matrices.

If (numerator, denominator) is passed in for ``*system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g. ``s^2 + 3s + 5`` or ``z^2 + 3z + 5`` would be represented as ``1, 3, 5``)

Examples -------- Construct the transfer function:

.. math:: H(s) = \fracs^2 + 3s + 3s^2 + 2s + 1

>>> from scipy import signal

>>> num = 1, 3, 3 >>> den = 1, 2, 1

>>> signal.TransferFunction(num, den) TransferFunctionContinuous( array(1., 3., 3.), array(1., 2., 1.), dt: None )

Construct the transfer function with a sampling time of 0.1 seconds:

.. math:: H(z) = \fracz^2 + 3z + 3z^2 + 2z + 1

>>> signal.TransferFunction(num, den, dt=0.1) TransferFunctionDiscrete( array(1., 3., 3.), array(1., 2., 1.), dt: 0.1 )

Convert system representation to `StateSpace`.

Returns ------- sys : instance of `StateSpace` State space model of the current system

Return a copy of the current `TransferFunction` system.

Returns ------- sys : instance of `TransferFunction` The current system (copy)

Convert system representation to `ZerosPolesGain`.

Returns ------- sys : instance of `ZerosPolesGain` Zeros, poles, gain representation of the current system

Print the object to a human-readable representation.

Print the object to a human-readable representation.

Pretty-print the object to a formatter.