# control.TransferFunction¶

class `control.``TransferFunction`(num, den[, dt])

A class for representing transfer functions

The TransferFunction class is used to represent systems in transfer function form.

The main data members are ‘num’ and ‘den’, which are 2-D lists of arrays containing MIMO numerator and denominator coefficients. For example,

```>>> num = numpy.array([1., 4., 8.])
```

means that the numerator of the transfer function from the 6th input to the 3rd output is set to s^2 + 4s + 8.

Discrete-time transfer functions are implemented by using the ‘dt’ instance variable and setting it to something other than ‘None’. If ‘dt’ has a non-zero value, then it must match whenever two transfer functions are combined. If ‘dt’ is set to True, the system will be treated as a discrete time system with unspecified sampling time.

The TransferFunction class defines two constants `s` and `z` that represent the differentiation and delay operators in continuous and discrete time. These can be used to create variables that allow algebraic creation of transfer functions. For example,

```>>> s = TransferFunction.s
>>> G  = (s + 1)/(s**2 + 2*s + 1)
```
`__init__`(*args)

TransferFunction(num, den[, dt])

Construct a transfer function.

The default constructor is TransferFunction(num, den), where num and den are lists of lists of arrays containing polynomial coefficients. To create a discrete time transfer funtion, use TransferFunction(num, den, dt) where ‘dt’ is the sampling time (or True for unspecified sampling time). To call the copy constructor, call TransferFunction(sys), where sys is a TransferFunction object (continuous or discrete).

Methods

 `__init__`(*args) TransferFunction(num, den[, dt]) `damp`() Natural frequency, damping ratio of system poles `dcgain`() Return the zero-frequency (or DC) gain `evalfr`(omega) Evaluate a transfer function at a single angular frequency. `feedback`([other, sign]) Feedback interconnection between two LTI objects. `freqresp`(omega) Evaluate a transfer function at a list of angular frequencies. `horner`(s) Evaluate the systems’s transfer function for a complex variable `isctime`([strict]) Check to see if a system is a continuous-time system `isdtime`([strict]) Check to see if a system is a discrete-time system `issiso`() Check to see if a system is single input, single output `minreal`([tol]) Remove cancelling pole/zero pairs from a transfer function `pole`() Compute the poles of a transfer function. `returnScipySignalLTI`() Return a list of a list of scipy.signal.lti objects. `sample`(Ts[, method, alpha]) Convert a continuous-time system to discrete time `zero`() Compute the zeros of a transfer function.

Attributes

 `s` `z`
`damp`()

Natural frequency, damping ratio of system poles

Returns: wn (array) – Natural frequencies for each system pole zeta (array) – Damping ratio for each system pole poles (array) – Array of system poles
`dcgain`()

Return the zero-frequency (or DC) gain

For a continous-time transfer function G(s), the DC gain is G(0) For a discrete-time transfer function G(z), the DC gain is G(1)

Returns: gain – The zero-frequency gain ndarray
`evalfr`(omega)

Evaluate a transfer function at a single angular frequency.

self._evalfr(omega) returns the value of the transfer function matrix with input value s = i * omega.

`feedback`(other=1, sign=-1)

Feedback interconnection between two LTI objects.

`freqresp`(omega)

Evaluate a transfer function at a list of angular frequencies.

mag, phase, omega = self.freqresp(omega)

reports the value of the magnitude, phase, and angular frequency of the transfer function matrix evaluated at s = i * omega, where omega is a list of angular frequencies, and is a sorted version of the input omega.

`horner`(s)

Evaluate the systems’s transfer function for a complex variable

Returns a matrix of values evaluated at complex variable s.

`isctime`(strict=False)

Check to see if a system is a continuous-time system

Parameters: sys (LTI system) – System to be checked strict (bool, optional) – If strict is True, make sure that timebase is not None. Default is False.
`isdtime`(strict=False)

Check to see if a system is a discrete-time system

Parameters: strict (bool, optional) – If strict is True, make sure that timebase is not None. Default is False.
`issiso`()

Check to see if a system is single input, single output

`minreal`(tol=None)

Remove cancelling pole/zero pairs from a transfer function

`pole`()

Compute the poles of a transfer function.

`returnScipySignalLTI`()

Return a list of a list of scipy.signal.lti objects.

For instance,

```>>> out = tfobject.returnScipySignalLTI()
>>> out
```

is a signal.scipy.lti object corresponding to the transfer function from the 6th input to the 4th output.

`sample`(Ts, method='zoh', alpha=None)

Convert a continuous-time system to discrete time

Creates a discrete-time system from a continuous-time system by sampling. Multiple methods of conversion are supported.

Parameters: Ts (float) – Sampling period method ({"gbt", "bilinear", "euler", "backward_diff",) – “zoh”, “matched”} Method to use for sampling: gbt: generalized bilinear transformation bilinear: Tustin’s approximation (“gbt” with alpha=0.5) euler: Euler (or forward difference) method (“gbt” with alpha=0) backward_diff: Backwards difference (“gbt” with alpha=1.0) zoh: zero-order hold (default) alpha (float within [0, 1]) – The generalized bilinear transformation weighting parameter, which should only be specified with method=”gbt”, and is ignored otherwise. sysd – Discrete time system, with sampling rate Ts StateSpace system

Notes

1. Available only for SISO systems
2. Uses the command cont2discrete from scipy.signal

Examples

```>>> sys = TransferFunction(1, [1,1])
>>> sysd = sys.sample(0.5, method='bilinear')
```
`zero`()

Compute the zeros of a transfer function.