polyadd, polymul, polyval, roots, sqrt, zeros, squeeze, exp, pi, \

where, delete, real, poly, nonzero

import scipy as sp

from scipy.signal import lti, tf2zpk, zpk2tf, cont2discrete

from scipy.signal import tf2zpk, zpk2tf, cont2discrete

from scipy.signal import TransferFunction as signalTransferFunction

from copy import deepcopy

from warnings import warn

from itertools import chain

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 default value of

'dt' is None and can be changed by changing the value of

discrete time system with unspecified sampling time. The default value of

'dt' is None and can be changed by changing the value of

``control.config.defaults['xferfcn.default_dt']``.

The TransferFunction class defines two constants ``s`` and ``z`` that

# end result

return TransferFunction(num, den, self.dt)

def returnScipySignalLTI(self):

def returnScipySignalLTI(self, strict=True):

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

For instance,

is a signal.scipy.lti object corresponding to the

transfer function from the 6th input to the 4th output.

Parameters

----------

strict : bool, optional

True (default):

`tfobject` must be continuous or discrete.

`tfobject.dt`cannot be None.

False:

if `tfobject.dt` is None, continuous time signal.TransferFunction

objects are is returned

Returns

-------

out : list of list of scipy.signal.TransferFunction

"""

if strict and self.dt is None:

raise ValueError("with strict=True, dt cannot be None")

# TODO: implement for discrete time systems

if self.dt != 0 and self.dt is not None:

raise NotImplementedError("Function not \

implemented in discrete time")

if self.dt:

kwdt = {'dt': self.dt}

else:

# scipy convention for continuous time lti systems: call without

# dt keyword argument

kwdt = {}

# Preallocate the output.

out = [[[] for j in range(self.inputs)] for i in range(self.outputs)]

for i in range(self.outputs):

for j in range(self.inputs):

out[i][j] = lti(self.num[i][j], self.den[i][j])

out[i][j] = signalTransferFunction(self.num[i][j],

self.den[i][j],

**kwdt)

return out

The generalized bilinear transformation weighting parameter, which

should only be specified with method="gbt", and is ignored

otherwise.

prewarp_frequency : float within [0, infinity)

The frequency [rad/s] at which to match with the input continuous-

time system's magnitude and phase (the gain=1 crossover frequency,

for example). Should only be specified with method='bilinear' or

time system's magnitude and phase (the gain=1 crossover frequency,

for example). Should only be specified with method='bilinear' or

'gbt' with alpha=0.5 and ignored otherwise.

Returns

if (method=='bilinear' or (method=='gbt' and alpha==0.5)) and \

prewarp_frequency is not None:

Twarp = 2*np.tan(prewarp_frequency*Ts/2)/prewarp_frequency

else:

else:

Twarp = Ts

numd, dend, _ = cont2discrete(sys, Twarp, method, alpha)

return TransferFunction(numd[0, :], dend, Ts)