scipy.signal.

TransferFunction#

class scipy.signal.TransferFunction(*system, **kwargs)[source]#

Linear Time Invariant system class in transfer function form.

Represents the system as the continuous-time transfer function \(H(s)=\sum_{i=0}^N b[N-i] s^i / \sum_{j=0}^M a[M-j] s^j\) or the discrete-time transfer function \(H(z)=\sum_{i=0}^N b[N-i] z^i / \sum_{j=0}^M a[M-j] z^j\), where \(b\) are elements of the numerator num, \(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 \(H(s) = \frac{s^2 + 3s + 3}{s^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 \(H(z) = \frac{z^2 + 3z + 3}{z^2 + 2z + 1}\) with a sampling time of 0.1 seconds:

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

Attributes:

den: Denominator of the TransferFunction system.
dt: Return the sampling time of the system, None for lti systems.
num: Numerator of the TransferFunction system.
poles: Poles of the system.
zeros: Zeros of the system.

Methods

`to_ss`()	Convert system representation to `StateSpace`.
`to_tf`()	Return a copy of the current `TransferFunction` system.
`to_zpk`()	Convert system representation to `ZerosPolesGain`.