"""TransferFunction(num, den[, dt])

def __init__(self, *args, **kwargs):

"""TransferFunction(num, den[, dt])

#

# Process positional arguments

#

if len(args) == 2:

# The user provided a numerator and a denominator.

num, den = args

elif len(args) == 3:

# Discrete time transfer function

num, den, dt = args

if 'dt' in kwargs:

warn("received multiple dt arguments, "

"using positional arg dt = %s" % dt)

kwargs['dt'] = dt

args = args[:-1]

elif len(args) == 1:

# Use the copy constructor.

if not isinstance(args[0], TransferFunction):

raise TypeError("The one-argument constructor can only take \

% type(args[0]))

num = args[0].num

den = args[0].den

else:

raise TypeError("Needs 1, 2 or 3 arguments; received %i."

% len(args))

num = _clean_part(num)

den = _clean_part(den)

#

# Process keyword arguments

#

# During module init, TransferFunction.s and TransferFunction.z

# get initialized when defaults are not fully initialized yet.

# Use 'poly' in these cases.

self.display_format = kwargs.pop(

'display_format',

config.defaults.get('xferfcn.display_format', 'poly'))

if self.display_format not in ('poly', 'zpk'):

raise ValueError("display_format must be 'poly' or 'zpk',"

" got '%s'" % self.display_format)

# Determine if the transfer function is static (needed for dt)

static = True

for col in num + den:

for poly in col:

if len(poly) > 1:

static = False

defaults = args[0] if len(args) == 1 else \

{'inputs': len(num[0]), 'outputs': len(num)}

name, inputs, outputs, states, dt = _process_iosys_keywords(

kwargs, defaults, static=static)

if states:

raise TypeError(

"states keyword not allowed for transfer functions")

# Initialize LTI (InputOutputSystem) object

super().__init__(

name=name, inputs=inputs, outputs=outputs, dt=dt, **kwargs)

#

# Check to make sure everything is consistent

#

# Make sure numerator and denominator matrices have consistent sizes

if self.ninputs != len(den[0]):

raise ValueError(

"The numerator has %i input(s), but the denominator has "

"%i input(s)." % (self.ninputs, len(den[0])))

if self.noutputs != len(den):

raise ValueError(

"The numerator has %i output(s), but the denominator has "

"%i output(s)." % (self.noutputs, len(den)))

# Additional checks/updates on structure of the transfer function

for i in range(self.noutputs):

# Make sure that each row has the same number of columns

if len(num[i]) != self.ninputs:

raise ValueError(

"Row 0 of the numerator matrix has %i elements, but row "

"%i has %i." % (self.ninputs, i, len(num[i])))

if len(den[i]) != self.ninputs:

raise ValueError(

"Row 0 of the denominator matrix has %i elements, but row "

"%i has %i." % (self.ninputs, i, len(den[i])))

# Check for zeros in numerator or denominator

# TODO: Right now these checks are only done during construction.

# It might be worthwhile to think of a way to perform checks if the

# user modifies the transfer function after construction.

for j in range(self.ninputs):

# Check that we don't have any zero denominators.

zeroden = True

for k in den[i][j]:

if k:

zeroden = False

break

if zeroden:

raise ValueError(

"Input %i, output %i has a zero denominator."

% (j + 1, i + 1))

# If we have zero numerators, set the denominator to 1.

zeronum = True

for k in num[i][j]:

if k:

zeronum = False

break

if zeronum:

den[i][j] = ones(1)

# Store the numerator and denominator

self.num = num

self.den = den

#

# Final processing

#

# Truncate leading zeros

self._truncatecoeff()

#

# Class attributes

#

# These attributes are defined as class attributes so that they are

# documented properly. They are "overwritten" in __init__.

#

#: Number of system inputs.

#:

#: :meta hide-value:

ninputs = 1

#: Number of system outputs.

#:

#: :meta hide-value:

noutputs = 1

#: Transfer function numerator polynomial (array)

#:

#: The numerator of the transfer function is stored as an 2D list of

#: arrays containing MIMO numerator coefficients, indexed by outputs and

#: inputs. For example, ``num[2][5]`` is the array of coefficients for

#: the numerator of the transfer function from the sixth input to the

#: third output.

#:

#: :meta hide-value:

num = [[0]]

#: Transfer function denominator polynomial (array)

#:

#: The numerator of the transfer function is store as an 2D list of

#: arrays containing MIMO numerator coefficients, indexed by outputs and

#: inputs. For example, ``den[2][5]`` is the array of coefficients for

#: the denominator of the transfer function from the sixth input to the

#: third output.

#:

#: :meta hide-value:

den = [[0]]

def __call__(self, x, squeeze=None, warn_infinite=True):

"""Evaluate system's transfer function at complex frequencies.

out = self.horner(x, warn_infinite=warn_infinite)

return _process_frequency_response(self, x, out, squeeze=squeeze)

def horner(self, x, warn_infinite=True):

"""Evaluate system's transfer function at complex frequency

# Make sure the argument is a 1D array of complex numbers

x_arr = np.atleast_1d(x).astype(complex, copy=False)

# Make sure that we are operating on a simple list

if len(x_arr.shape) > 1:

raise ValueError("input list must be 1D")

# Initialize the output matrix in the proper shape

out = empty((self.noutputs, self.ninputs, len(x_arr)), dtype=complex)

# Set up error processing based on warn_infinite flag

with np.errstate(all='warn' if warn_infinite else 'ignore'):

for i in range(self.noutputs):

for j in range(self.ninputs):

out[i][j] = (polyval(self.num[i][j], x_arr) /

polyval(self.den[i][j], x_arr))

return out

def _truncatecoeff(self):

"""Remove extraneous zero coefficients from num and den.

# Beware: this is a shallow copy. This should be okay.

data = [self.num, self.den]

for p in range(len(data)):

for i in range(self.noutputs):

for j in range(self.ninputs):

# Find the first nontrivial coefficient.

nonzero = None

for k in range(data[p][i][j].size):

if data[p][i][j][k]:

nonzero = k

break

if nonzero is None:

# The array is all zeros.

data[p][i][j] = zeros(1)

else:

# Truncate the trivial coefficients.

data[p][i][j] = data[p][i][j][nonzero:]

[self.num, self.den] = data

def __str__(self, var=None):

"""String representation of the transfer function.

mimo = not self.issiso()

if var is None:

var = 's' if self.isctime() else 'z'

outstr = f"{InputOutputSystem.__str__(self)}\n"

for ni in range(self.ninputs):

for no in range(self.noutputs):

if mimo:

outstr += "\nInput %i to output %i:" % (ni + 1, no + 1)

# Convert the numerator and denominator polynomials to strings.

if self.display_format == 'poly':

numstr = _tf_polynomial_to_string(self.num[no][ni], var=var)

denstr = _tf_polynomial_to_string(self.den[no][ni], var=var)

elif self.display_format == 'zpk':

num = self.num[no][ni]

if num.size == 1 and num.item() == 0:

# Catch a special case that SciPy doesn't handle

z, p, k = tf2zpk([1.], self.den[no][ni])

k = 0

else:

z, p, k = tf2zpk(self.num[no][ni], self.den[no][ni])

numstr = _tf_factorized_polynomial_to_string(

z, gain=k, var=var)

denstr = _tf_factorized_polynomial_to_string(p, var=var)

# Figure out the length of the separating line

dashcount = max(len(numstr), len(denstr))

dashes = '-' * dashcount

# Center the numerator or denominator

if len(numstr) < dashcount:

numstr = ' ' * ((dashcount - len(numstr)) // 2) + numstr

if len(denstr) < dashcount:

denstr = ' ' * ((dashcount - len(denstr)) // 2) + denstr

outstr += "\n" + numstr + "\n" + dashes + "\n" + denstr + "\n"

# If this is a strict discrete time system, print the sampling time

if type(self.dt) != bool and self.isdtime(strict=True):

outstr += "\ndt = " + str(self.dt) + "\n"

return outstr

# represent to implement a re-loadable version

def __repr__(self):

"""Print transfer function in loadable form"""

if self.issiso():

return "TransferFunction({num}, {den}{dt})".format(

num=self.num[0][0].__repr__(), den=self.den[0][0].__repr__(),

dt=', {}'.format(self.dt) if isdtime(self, strict=True)

else '')

else:

return "TransferFunction({num}, {den}{dt})".format(

num=self.num.__repr__(), den=self.den.__repr__(),

dt=', {}'.format(self.dt) if isdtime(self, strict=True)

else '')

def _repr_latex_(self, var=None):

"""LaTeX representation of transfer function, for Jupyter notebook"""

mimo = not self.issiso()

if var is None:

var = 's' if self.isctime() else 'z'

out = ['$$']

if mimo:

out.append(r"\begin{bmatrix}")

for no in range(self.noutputs):

for ni in range(self.ninputs):

# Convert the numerator and denominator polynomials to strings.

if self.display_format == 'poly':

numstr = _tf_polynomial_to_string(self.num[no][ni], var=var)

denstr = _tf_polynomial_to_string(self.den[no][ni], var=var)

elif self.display_format == 'zpk':

z, p, k = tf2zpk(self.num[no][ni], self.den[no][ni])

numstr = _tf_factorized_polynomial_to_string(

z, gain=k, var=var)

denstr = _tf_factorized_polynomial_to_string(p, var=var)

numstr = _tf_string_to_latex(numstr, var=var)

denstr = _tf_string_to_latex(denstr, var=var)

out += [r"\frac{", numstr, "}{", denstr, "}"]

if mimo and ni < self.ninputs - 1:

out.append("&")

if mimo:

out.append(r"\\")

if mimo:

out.append(r" \end{bmatrix}")

# See if this is a discrete time system with specific sampling time

if not (self.dt is None) and type(self.dt) != bool and self.dt > 0:

out += [r"\quad dt = ", str(self.dt)]

out.append("$$")

return ''.join(out)

def __neg__(self):

"""Negate a transfer function."""

num = deepcopy(self.num)

for i in range(self.noutputs):

for j in range(self.ninputs):

num[i][j] *= -1

return TransferFunction(num, self.den, self.dt)

def __add__(self, other):

"""Add two LTI objects (parallel connection)."""

from .statesp import StateSpace

# Convert the second argument to a transfer function.

if isinstance(other, StateSpace):

other = _convert_to_transfer_function(other)

elif isinstance(other, (int, float, complex, np.number, np.ndarray)):

other = _convert_to_transfer_function(other, inputs=self.ninputs,

outputs=self.noutputs)

if not isinstance(other, TransferFunction):

return NotImplemented

# Check that the input-output sizes are consistent.

if self.ninputs != other.ninputs:

raise ValueError(

"The first summand has %i input(s), but the second has %i."

% (self.ninputs, other.ninputs))

if self.noutputs != other.noutputs:

raise ValueError(

"The first summand has %i output(s), but the second has %i."

% (self.noutputs, other.noutputs))

dt = common_timebase(self.dt, other.dt)

# Preallocate the numerator and denominator of the sum.

num = [[[] for j in range(self.ninputs)] for i in range(self.noutputs)]

den = [[[] for j in range(self.ninputs)] for i in range(self.noutputs)]

for i in range(self.noutputs):

for j in range(self.ninputs):

num[i][j], den[i][j] = _add_siso(

self.num[i][j], self.den[i][j],

other.num[i][j], other.den[i][j])

return TransferFunction(num, den, dt)

def __radd__(self, other):

"""Right add two LTI objects (parallel connection)."""

return self + other

def __sub__(self, other):

"""Subtract two LTI objects."""

return self + (-other)

def __rsub__(self, other):

"""Right subtract two LTI objects."""

return other + (-self)

def __mul__(self, other):

"""Multiply two LTI objects (serial connection)."""

from .statesp import StateSpace

# Convert the second argument to a transfer function.

if isinstance(other, StateSpace):

other = _convert_to_transfer_function(other)

elif isinstance(other, (int, float, complex, np.number, np.ndarray)):

other = _convert_to_transfer_function(other, inputs=self.ninputs,

outputs=self.noutputs)

if not isinstance(other, TransferFunction):

return NotImplemented

# Check that the input-output sizes are consistent.

if self.ninputs != other.noutputs:

raise ValueError(

"C = A * B: A has %i column(s) (input(s)), but B has %i "

"row(s)\n(output(s))." % (self.ninputs, other.noutputs))

inputs = other.ninputs

outputs = self.noutputs

dt = common_timebase(self.dt, other.dt)

# Preallocate the numerator and denominator of the sum.

num = [[[0] for j in range(inputs)] for i in range(outputs)]

den = [[[1] for j in range(inputs)] for i in range(outputs)]

# Temporary storage for the summands needed to find the (i, j)th

# element of the product.

num_summand = [[] for k in range(self.ninputs)]

den_summand = [[] for k in range(self.ninputs)]

# Multiply & add.

for row in range(outputs):

for col in range(inputs):

for k in range(self.ninputs):

num_summand[k] = polymul(

self.num[row][k], other.num[k][col])

den_summand[k] = polymul(

self.den[row][k], other.den[k][col])

num[row][col], den[row][col] = _add_siso(

num[row][col], den[row][col],

num_summand[k], den_summand[k])

return TransferFunction(num, den, dt)

def __rmul__(self, other):

"""Right multiply two LTI objects (serial connection)."""

# Convert the second argument to a transfer function.

if isinstance(other, (int, float, complex, np.number)):

other = _convert_to_transfer_function(other, inputs=self.ninputs,

outputs=self.ninputs)

else:

other = _convert_to_transfer_function(other)

# Check that the input-output sizes are consistent.

if other.ninputs != self.noutputs:

raise ValueError(

"C = A * B: A has %i column(s) (input(s)), but B has %i "

"row(s)\n(output(s))." % (other.ninputs, self.noutputs))

inputs = self.ninputs

outputs = other.noutputs

dt = common_timebase(self.dt, other.dt)

# Preallocate the numerator and denominator of the sum.

num = [[[0] for j in range(inputs)] for i in range(outputs)]

den = [[[1] for j in range(inputs)] for i in range(outputs)]

# Temporary storage for the summands needed to find the

# (i, j)th element

# of the product.

num_summand = [[] for k in range(other.ninputs)]

den_summand = [[] for k in range(other.ninputs)]

for i in range(outputs): # Iterate through rows of product.

for j in range(inputs): # Iterate through columns of product.

for k in range(other.ninputs): # Multiply & add.

num_summand[k] = polymul(other.num[i][k], self.num[k][j])

den_summand[k] = polymul(other.den[i][k], self.den[k][j])

num[i][j], den[i][j] = _add_siso(

num[i][j], den[i][j],

num_summand[k], den_summand[k])

return TransferFunction(num, den, dt)

# TODO: Division of MIMO transfer function objects is not written yet.

def __truediv__(self, other):

"""Divide two LTI objects."""

if isinstance(other, (int, float, complex, np.number)):

other = _convert_to_transfer_function(

other, inputs=self.ninputs,

outputs=self.ninputs)

else:

other = _convert_to_transfer_function(other)

if (self.ninputs > 1 or self.noutputs > 1 or

other.ninputs > 1 or other.noutputs > 1):

raise NotImplementedError(

"TransferFunction.__truediv__ is currently \

implemented only for SISO systems.")

dt = common_timebase(self.dt, other.dt)

num = polymul(self.num[0][0], other.den[0][0])

den = polymul(self.den[0][0], other.num[0][0])

return TransferFunction(num, den, dt)

# TODO: Division of MIMO transfer function objects is not written yet.

def __rtruediv__(self, other):

"""Right divide two LTI objects."""

if isinstance(other, (int, float, complex, np.number)):

other = _convert_to_transfer_function(

other, inputs=self.ninputs,

outputs=self.ninputs)

else:

other = _convert_to_transfer_function(other)

if (self.ninputs > 1 or self.noutputs > 1 or

other.ninputs > 1 or other.noutputs > 1):

raise NotImplementedError(

"TransferFunction.__rtruediv__ is currently implemented only "

"for SISO systems.")

return other / self

def __pow__(self, other):

if not type(other) == int:

raise ValueError("Exponent must be an integer")

if other == 0:

return TransferFunction([1], [1]) # unity

if other > 0:

return self * (self**(other - 1))

if other < 0:

return (TransferFunction([1], [1]) / self) * (self**(other + 1))

def __getitem__(self, key):

if not isinstance(key, Iterable) or len(key) != 2:

raise IOError('must provide indices of length 2 for transfer functions')

key1, key2 = key

if not isinstance(key1, (int, slice)) or not isinstance(key2, (int, slice)):

raise TypeError(f"system indices must be integers or slices")

# pre-process

if isinstance(key1, int):

key1 = slice(key1, key1 + 1, 1)

if isinstance(key2, int):

key2 = slice(key2, key2 + 1, 1)

# dim1

start1, stop1, step1 = key1.start, key1.stop, key1.step

if step1 is None:

step1 = 1

if start1 is None:

start1 = 0

if stop1 is None:

stop1 = len(self.num)

# dim1

start2, stop2, step2 = key2.start, key2.stop, key2.step

if step2 is None:

step2 = 1

if start2 is None:

start2 = 0

if stop2 is None:

stop2 = len(self.num[0])

num, den = [], []

for i in range(start1, stop1, step1):

num_i = []

den_i = []

for j in range(start2, stop2, step2):

num_i.append(self.num[i][j])

den_i.append(self.den[i][j])

num.append(num_i)

den.append(den_i)

# Save the label names

outputs = [self.output_labels[i] for i in range(start1, stop1, step1)]

inputs = [self.input_labels[j] for j in range(start2, stop2, step2)]

# Create the system name

sysname = config.defaults['iosys.indexed_system_name_prefix'] + \

self.name + config.defaults['iosys.indexed_system_name_suffix']

return TransferFunction(

num, den, self.dt, inputs=inputs, outputs=outputs, name=sysname)

def freqresp(self, omega):

"""Evaluate transfer function at complex frequencies.

warn("TransferFunction.freqresp(omega) will be removed in a "

"future release of python-control; use "

"sys.frequency_response(omega), or freqresp(sys, omega) in the "

"MATLAB compatibility module instead", FutureWarning)

return self.frequency_response(omega)

def poles(self):

"""Compute the poles of a transfer function."""

_, den, denorder = self._common_den(allow_nonproper=True)

rts = []

for d, o in zip(den, denorder):

rts.extend(roots(d[:o + 1]))

return np.array(rts).astype(complex)

def zeros(self):

"""Compute the zeros of a transfer function."""

if self.ninputs > 1 or self.noutputs > 1:

raise NotImplementedError(

"TransferFunction.zeros is currently only implemented "

"for SISO systems.")

else:

# for now, just give zeros of a SISO tf

return roots(self.num[0][0]).astype(complex)

def feedback(self, other=1, sign=-1):

"""Feedback interconnection between two LTI objects."""

other = _convert_to_transfer_function(other)

if (self.ninputs > 1 or self.noutputs > 1 or

other.ninputs > 1 or other.noutputs > 1):

# TODO: MIMO feedback

raise ControlMIMONotImplemented(

"TransferFunction.feedback is currently not implemented for "

"MIMO systems.")

dt = common_timebase(self.dt, other.dt)

num1 = self.num[0][0]

den1 = self.den[0][0]

num2 = other.num[0][0]

den2 = other.den[0][0]

num = polymul(num1, den2)

den = polyadd(polymul(den2, den1), -sign * polymul(num2, num1))

return TransferFunction(num, den, dt)

# For MIMO or SISO systems, the analytic expression is

# self / (1 - sign * other * self)

# But this does not work correctly because the state size will be too

# large.

def minreal(self, tol=None):

"""Remove cancelling pole/zero pairs from a transfer function"""

# based on octave minreal

# default accuracy

from sys import float_info

sqrt_eps = sqrt(float_info.epsilon)

# pre-allocate arrays

num = [[[] for j in range(self.ninputs)] for i in range(self.noutputs)]

den = [[[] for j in range(self.ninputs)] for i in range(self.noutputs)]

for i in range(self.noutputs):

for j in range(self.ninputs):

# split up in zeros, poles and gain

newzeros = []

zeros = roots(self.num[i][j])

poles = roots(self.den[i][j])

gain = self.num[i][j][0] / self.den[i][j][0]

# check all zeros

for z in zeros:

t = tol or \

1000 * max(float_info.epsilon, abs(z) * sqrt_eps)

idx = where(abs(z - poles) < t)[0]

if len(idx):

# cancel this zero against one of the poles

poles = delete(poles, idx[0])

else:

# keep this zero

newzeros.append(z)

# poly([]) returns a scalar, but we always want a 1d array

num[i][j] = np.atleast_1d(gain * real(poly(newzeros)))

den[i][j] = np.atleast_1d(real(poly(poles)))

# end result

return TransferFunction(num, den, self.dt)

def returnScipySignalLTI(self, strict=True):

"""Return a list of a list of :class:`scipy.signal.lti` objects.

if strict and self.dt is None:

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

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.ninputs)] for i in range(self.noutputs)]

for i in range(self.noutputs):

for j in range(self.ninputs):

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

self.den[i][j],

**kwdt)

return out

def _common_den(self, imag_tol=None, allow_nonproper=False):

"""