o jgnR@sddlmZddlmZmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZmZmZdd lmZdd lmZddlm Z m!Z!ddl"m#Z#ddl$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlm?Z?ddl@mAZAgdZBddZCddZDdd ZEd!d"ZFd#d$ZGd%d&ZHd'd(ZIGd)d*d*e eZJGd+d,d,eJZKGd-d.d.eJZLeKeK_MeLeL_Md/d0ZNd1d2ZOGd3d4d4eKZPd5d6ZQd7d8ZRGd9d:d:eKZSd;d<ZTGd=d>d>eLZUGd?d@d@eKZVGdAdBdBeLZWGdCdDdDePZXdEdFZYGdGdHdHeLZZdIdJZ[GdKdLdLeLZ\GdMdNdNeJZ]dOS)P)Type)IntervalnumerRationalsolveset)Add)BasicTuple) EvalfMixin)Exprexpand) fuzzy_and)Mul)Ipioo)Pow)S)DummySymbol)Abs)sympify_sympify)MatrixImmutableMatrixImmutableDenseMatrixeye ShapeErrorzeros)explog)MatMulMatAdd)Polyrootof)roots)canceldegree)limit) filldedent) prec_to_dps)TransferFunctionSeries MIMOSeriesParallel MIMOParallelFeedback MIMOFeedbackTransferFunctionMatrix StateSpacegbtbilinear forward_diff backward_diff phase_margin gain_margincs>tdd}t}t||krfddt|D}|S)z4 like roots, but works on higher-order polynomials. T)multiplecsg|]}t|qS)r&).0kpolyvarr=Q/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/physics/control/lti.py %sz_roots..)r'r)lenrange)rArBrnr=r@rC_roots s  rIc s|jstd||j}||j|}|j|}tdt t |t |dt fddt |dddt t |D}t fddt |dddt t |D}|}|} | d fd d|D}fd d| D} || fS) a  Returns falling coefficients of H(z) from numerator and denominator. Explanation =========== Where H(z) is the corresponding discretized transfer function, discretized with the generalised bilinear transformation method. H(z) is obtained from the continuous transfer function H(s) by substituting $s(z) = \frac{z-1}{T(\alpha z + (1-\alpha))}$ into H(s), where T is the sample period. Coefficients are falling, i.e. $H(z) = \frac{az+b}{cz+d}$ is returned as [a, b], [c, d]. Examples ======== >>> from sympy.physics.control.lti import TransferFunction, gbt >>> from sympy.abc import s, L, R, T >>> tf = TransferFunction(1, s*L + R, s) >>> numZ, denZ = gbt(tf, T, 0.5) >>> numZ [T/(2*(L + R*T/2)), T/(2*(L + R*T/2))] >>> denZ [1, (-L + R*T/2)/(L + R*T/2)] >>> numZ, denZ = gbt(tf, T, 0) >>> numZ [T/L] >>> denZ [1, (-L + R*T)/L] >>> numZ, denZ = gbt(tf, T, 1) >>> numZ [T/(L + R*T), 0] >>> denZ [1, -L/(L + R*T)] >>> numZ, denZ = gbt(tf, T, 0.3) >>> numZ [3*T/(10*(L + 3*R*T/10)), 7*T/(10*(L + 3*R*T/10))] >>> denZ [1, (-L + 7*R*T/10)/(L + 3*R*T/10)] References ========== .. [1] https://www.polyu.edu.hk/ama/profile/gfzhang/Research/ZCC09_IJC.pdf z!Not implemented for MIMO systems.icDg|]\}}||d|d|qSrJr=r>ciNTalphazr=rCrDhDzgbt..NcrKrLr=rMrPr=rCrDirUrcg|]}|qSr=r=r>coefparar=rCrDocrWr=r=rXrZr=rCrDpr\)is_SISONotImplementedErrorrBnumas_poly all_coeffsdenrlimit_denominatormaxrErziprF) tf sample_perrSsnpdpr_rb num_coefs den_coefsr=)rQrRrSr[rTrCr6(s"344r6cCt||tjS)a5 Returns falling coefficients of H(z) from numerator and denominator. Explanation =========== Where H(z) is the corresponding discretized transfer function, discretized with the bilinear transform method. H(z) is obtained from the continuous transfer function H(s) by substituting $s(z) = \frac{2}{T}\frac{z-1}{z+1}$ into H(s), where T is the sample period. Coefficients are falling, i.e. $H(z) = \frac{az+b}{cz+d}$ is returned as [a, b], [c, d]. Examples ======== >>> from sympy.physics.control.lti import TransferFunction, bilinear >>> from sympy.abc import s, L, R, T >>> tf = TransferFunction(1, s*L + R, s) >>> numZ, denZ = bilinear(tf, T) >>> numZ [T/(2*(L + R*T/2)), T/(2*(L + R*T/2))] >>> denZ [1, (-L + R*T/2)/(L + R*T/2)] )r6rHalfrfrgr=r=rCr7tr7cCrm)a  Returns falling coefficients of H(z) from numerator and denominator. Explanation =========== Where H(z) is the corresponding discretized transfer function, discretized with the forward difference transform method. H(z) is obtained from the continuous transfer function H(s) by substituting $s(z) = \frac{z-1}{T}$ into H(s), where T is the sample period. Coefficients are falling, i.e. $H(z) = \frac{az+b}{cz+d}$ is returned as [a, b], [c, d]. Examples ======== >>> from sympy.physics.control.lti import TransferFunction, forward_diff >>> from sympy.abc import s, L, R, T >>> tf = TransferFunction(1, s*L + R, s) >>> numZ, denZ = forward_diff(tf, T) >>> numZ [T/L] >>> denZ [1, (-L + R*T)/L] )r6rZeroror=r=rCr8rpr8cCrm)a Returns falling coefficients of H(z) from numerator and denominator. Explanation =========== Where H(z) is the corresponding discretized transfer function, discretized with the backward difference transform method. H(z) is obtained from the continuous transfer function H(s) by substituting $s(z) = \frac{z-1}{Tz}$ into H(s), where T is the sample period. Coefficients are falling, i.e. $H(z) = \frac{az+b}{cz+d}$ is returned as [a, b], [c, d]. Examples ======== >>> from sympy.physics.control.lti import TransferFunction, backward_diff >>> from sympy.abc import s, L, R, T >>> tf = TransferFunction(1, s*L + R, s) >>> numZ, denZ = backward_diff(tf, T) >>> numZ [T/(L + R*T), 0] >>> denZ [1, -L/(L + R*T)] )r6rOneror=r=rCr9rpr9c Csddlm}t|tstdtddd}t|}|}t|j }| t r+t d|dkr3td | |j|i}d tt|d }tt||tdtdd }t|dkr\td } n|d} ||tdt || itdd} | dkr}| d} | S)am Returns the phase margin of a continuous time system. Only applicable to Transfer Functions which can generate valid bode plots. Raises ====== NotImplementedError When time delay terms are present in the system. ValueError When a SISO LTI system is not passed. When more than one free symbol is present in the system. The only variable in the transfer function should be the variable of the Laplace transform. Examples ======== >>> from sympy.physics.control import TransferFunction, phase_margin >>> from sympy.abc import s >>> tf = TransferFunction(1, s**3 + 2*s**2 + s, s) >>> phase_margin(tf) 180*(-pi + atan((-1 + (-2*18**(1/3)/(9 + sqrt(93))**(1/3) + 12**(1/3)*(9 + sqrt(93))**(1/3))**2/36)/(-12**(1/3)*(9 + sqrt(93))**(1/3)/3 + 2*18**(1/3)/(3*(9 + sqrt(93))**(1/3)))))/pi + 180 >>> phase_margin(tf).n() 21.3863897518751 >>> tf1 = TransferFunction(s**3, s**2 + 5*s, s) >>> phase_margin(tf1) -180 + 180*(atan(sqrt(2)*(-51/10 - sqrt(101)/10)*sqrt(1 + sqrt(101))/(2*(sqrt(101)/2 + 51/2))) + pi)/pi >>> phase_margin(tf1).n() -25.1783920627277 >>> tf2 = TransferFunction(1, s + 1, s) >>> phase_margin(tf2) -180 See Also ======== gain_margin References ========== .. [1] https://en.wikipedia.org/wiki/Phase_margin r)arg1Margins are only applicable for SISO LTI systems.wTreal>> from sympy.physics.control import TransferFunction, gain_margin >>> from sympy.abc import s >>> tf = TransferFunction(1, s**3 + 2*s**2 + s, s) >>> gain_margin(tf) 20*log(2)/log(10) >>> gain_margin(tf).n() 6.02059991327962 >>> tf1 = TransferFunction(s**3, s**2 + 5*s, s) >>> gain_margin(tf1) oo See Also ======== phase_margin References ========== https://en.wikipedia.org/wiki/Bode_plot rtruTrvrxrJryrzr{rr|)rrrrrrrErrr!r^rrBr"rrrr as_real_imagr(rr) rrrrrrrphase phase_solgmwcgr=r=rCr;!s( -   * r;csBeZdZUdZeed<fddZeddZe ddZ Z S) LinearTimeInvariantzCA common class for all the Linear Time-Invariant Dynamical Systems._clstypecs.|turtdtt|j|g|Ri|S)Nz5The LTICommon class is not meant to be used directly.)rr^super__new__)clsrkwargs __class__r=rCrpszLinearTimeInvariant.__new__csj|stdtfdd|Dstdjddd|D}t|dkr3ttd t|d dS) Nz#At least 1 argument must be passed.c3s|] }t|jVqdSN)rrr>rsrr=rC yz2LinearTimeInvariant._check_args..zAll arguments must be of type .cSsh|]}|jqSr=rBrr=r=rC {z2LinearTimeInvariant._check_args..rJzw All transfer functions should use the same complex variable of the Laplace transform. z( different values found.)rall TypeErrorrrEr+)rargsvar_setr=rrC _check_argsus  zLinearTimeInvariant._check_argscC|jS)zCReturns `True` if the passed LTI system is SISO else returns False.)_is_SISOselfr=r=rCr]szLinearTimeInvariant.is_SISO) __name__ __module__ __qualname____doc__r__annotations__r classmethodrpropertyr] __classcell__r=r=rrCrjs    rc@eZdZdZdZdS)rzHA common class for all the SISO Linear Time-Invariant Dynamical Systems.TNrrrrrr=r=r=rCrrc@r)MIMOLinearTimeInvariantzHA common class for all the MIMO Linear Time-Invariant Dynamical Systems.FNrr=r=r=rCrrrcfdd}|S)Nc t|dts tS|i|SNrV)rrNotImplementedrrfuncr=rCwrapperz"_check_other_SISO..wrapperr=rrr=rrC_check_other_SISO rcr)Ncrr)rrrrrr=rCrrz"_check_other_MIMO..wrapperr=rr=rrC_check_other_MIMOrrcs.eZdZdZfddZed=ddZeddZed d Ze d d Z e d dZ e ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.ZeZd/d0ZeZd1d2Zd3d4Z e d5d6Z!e d7d8Z"e d9d:Z#d;d<Z$Z%S)>r-a! A class for representing LTI (Linear, time-invariant) systems that can be strictly described by ratio of polynomials in the Laplace transform complex variable. The arguments are ``num``, ``den``, and ``var``, where ``num`` and ``den`` are numerator and denominator polynomials of the ``TransferFunction`` respectively, and the third argument is a complex variable of the Laplace transform used by these polynomials of the transfer function. ``num`` and ``den`` can be either polynomials or numbers, whereas ``var`` has to be a :py:class:`~.Symbol`. Explanation =========== Generally, a dynamical system representing a physical model can be described in terms of Linear Ordinary Differential Equations like - $\small{b_{m}y^{\left(m\right)}+b_{m-1}y^{\left(m-1\right)}+\dots+b_{1}y^{\left(1\right)}+b_{0}y= a_{n}x^{\left(n\right)}+a_{n-1}x^{\left(n-1\right)}+\dots+a_{1}x^{\left(1\right)}+a_{0}x}$ Here, $x$ is the input signal and $y$ is the output signal and superscript on both is the order of derivative (not exponent). Derivative is taken with respect to the independent variable, $t$. Also, generally $m$ is greater than $n$. It is not feasible to analyse the properties of such systems in their native form therefore, we use mathematical tools like Laplace transform to get a better perspective. Taking the Laplace transform of both the sides in the equation (at zero initial conditions), we get - $\small{\mathcal{L}[b_{m}y^{\left(m\right)}+b_{m-1}y^{\left(m-1\right)}+\dots+b_{1}y^{\left(1\right)}+b_{0}y]= \mathcal{L}[a_{n}x^{\left(n\right)}+a_{n-1}x^{\left(n-1\right)}+\dots+a_{1}x^{\left(1\right)}+a_{0}x]}$ Using the linearity property of Laplace transform and also considering zero initial conditions (i.e. $\small{y(0^{-}) = 0}$, $\small{y'(0^{-}) = 0}$ and so on), the equation above gets translated to - $\small{b_{m}\mathcal{L}[y^{\left(m\right)}]+\dots+b_{1}\mathcal{L}[y^{\left(1\right)}]+b_{0}\mathcal{L}[y]= a_{n}\mathcal{L}[x^{\left(n\right)}]+\dots+a_{1}\mathcal{L}[x^{\left(1\right)}]+a_{0}\mathcal{L}[x]}$ Now, applying Derivative property of Laplace transform, $\small{b_{m}s^{m}\mathcal{L}[y]+\dots+b_{1}s\mathcal{L}[y]+b_{0}\mathcal{L}[y]= a_{n}s^{n}\mathcal{L}[x]+\dots+a_{1}s\mathcal{L}[x]+a_{0}\mathcal{L}[x]}$ Here, the superscript on $s$ is **exponent**. Note that the zero initial conditions assumption, mentioned above, is very important and cannot be ignored otherwise the dynamical system cannot be considered time-independent and the simplified equation above cannot be reached. Collecting $\mathcal{L}[y]$ and $\mathcal{L}[x]$ terms from both the sides and taking the ratio $\frac{ \mathcal{L}\left\{y\right\} }{ \mathcal{L}\left\{x\right\} }$, we get the typical rational form of transfer function. The numerator of the transfer function is, therefore, the Laplace transform of the output signal (The signals are represented as functions of time) and similarly, the denominator of the transfer function is the Laplace transform of the input signal. It is also a convention to denote the input and output signal's Laplace transform with capital alphabets like shown below. $H(s) = \frac{Y(s)}{X(s)} = \frac{ \mathcal{L}\left\{y(t)\right\} }{ \mathcal{L}\left\{x(t)\right\} }$ $s$, also known as complex frequency, is a complex variable in the Laplace domain. It corresponds to the equivalent variable $t$, in the time domain. Transfer functions are sometimes also referred to as the Laplace transform of the system's impulse response. Transfer function, $H$, is represented as a rational function in $s$ like, $H(s) =\ \frac{a_{n}s^{n}+a_{n-1}s^{n-1}+\dots+a_{1}s+a_{0}}{b_{m}s^{m}+b_{m-1}s^{m-1}+\dots+b_{1}s+b_{0}}$ Parameters ========== num : Expr, Number The numerator polynomial of the transfer function. den : Expr, Number The denominator polynomial of the transfer function. var : Symbol Complex variable of the Laplace transform used by the polynomials of the transfer function. Raises ====== TypeError When ``var`` is not a Symbol or when ``num`` or ``den`` is not a number or a polynomial. ValueError When ``den`` is zero. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction(s + a, s**2 + s + 1, s) >>> tf1 TransferFunction(a + s, s**2 + s + 1, s) >>> tf1.num a + s >>> tf1.den s**2 + s + 1 >>> tf1.var s >>> tf1.args (a + s, s**2 + s + 1, s) Any complex variable can be used for ``var``. >>> tf2 = TransferFunction(a*p**3 - a*p**2 + s*p, p + a**2, p) >>> tf2 TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p) >>> tf3 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p) >>> tf3 TransferFunction((p - 1)*(p + 3), (p - 1)*(p + 5), p) To negate a transfer function the ``-`` operator can be prepended: >>> tf4 = TransferFunction(-a + s, p**2 + s, p) >>> -tf4 TransferFunction(a - s, p**2 + s, p) >>> tf5 = TransferFunction(s**4 - 2*s**3 + 5*s + 4, s + 4, s) >>> -tf5 TransferFunction(-s**4 + 2*s**3 - 5*s - 4, s + 4, s) You can use a float or an integer (or other constants) as numerator and denominator: >>> tf6 = TransferFunction(1/2, 4, s) >>> tf6.num 0.500000000000000 >>> tf6.den 4 >>> tf6.var s >>> tf6.args (0.5, 4, s) You can take the integer power of a transfer function using the ``**`` operator: >>> tf7 = TransferFunction(s + a, s - a, s) >>> tf7**3 TransferFunction((a + s)**3, (-a + s)**3, s) >>> tf7**0 TransferFunction(1, 1, s) >>> tf8 = TransferFunction(p + 4, p - 3, p) >>> tf8**-1 TransferFunction(p - 3, p + 4, p) Addition, subtraction, and multiplication of transfer functions can form unevaluated ``Series`` or ``Parallel`` objects. >>> tf9 = TransferFunction(s + 1, s**2 + s + 1, s) >>> tf10 = TransferFunction(s - p, s + 3, s) >>> tf11 = TransferFunction(4*s**2 + 2*s - 4, s - 1, s) >>> tf12 = TransferFunction(1 - s, s**2 + 4, s) >>> tf9 + tf10 Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s)) >>> tf10 - tf11 Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-4*s**2 - 2*s + 4, s - 1, s)) >>> tf9 * tf10 Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s)) >>> tf10 - (tf9 + tf12) Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-s - 1, s**2 + s + 1, s), TransferFunction(s - 1, s**2 + 4, s)) >>> tf10 - (tf9 * tf12) Parallel(TransferFunction(-p + s, s + 3, s), Series(TransferFunction(-1, 1, s), TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s))) >>> tf11 * tf10 * tf9 Series(TransferFunction(4*s**2 + 2*s - 4, s - 1, s), TransferFunction(-p + s, s + 3, s), TransferFunction(s + 1, s**2 + s + 1, s)) >>> tf9 * tf11 + tf10 * tf12 Parallel(Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s)), Series(TransferFunction(-p + s, s + 3, s), TransferFunction(1 - s, s**2 + 4, s))) >>> (tf9 + tf12) * (tf10 + tf11) Series(Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s)), Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s))) These unevaluated ``Series`` or ``Parallel`` objects can convert into the resultant transfer function using ``.doit()`` method or by ``.rewrite(TransferFunction)``. >>> ((tf9 + tf10) * tf12).doit() TransferFunction((1 - s)*((-p + s)*(s**2 + s + 1) + (s + 1)*(s + 3)), (s + 3)*(s**2 + 4)*(s**2 + s + 1), s) >>> (tf9 * tf10 - tf11 * tf12).rewrite(TransferFunction) TransferFunction(-(1 - s)*(s + 3)*(s**2 + s + 1)*(4*s**2 + 2*s - 4) + (-p + s)*(s - 1)*(s + 1)*(s**2 + 4), (s - 1)*(s + 3)*(s**2 + 4)*(s**2 + s + 1), s) See Also ======== Feedback, Series, Parallel References ========== .. [1] https://en.wikipedia.org/wiki/Transfer_function .. [2] https://en.wikipedia.org/wiki/Laplace_transform cst|t|}}t|tstd|dkrtdt|ttttfr(| ts+|j rGt|ttttfr9| ts<|j rGt t| ||||Std)Nz Variable input must be a Symbol.r0TransferFunction cannot have a zero denominator.zBUnsupported type for numerator or denominator of TransferFunction.) rrrrrr r-r.r0r is_numberrr)rr_rbrBrr=rCrds "zTransferFunction.__new__NcCst|}|dur-|j}t|}|dkrt|d}n|dkr$ttdttd||\}}|dks=|t j rAt d||||S)a Creates a new ``TransferFunction`` efficiently from a rational expression. Parameters ========== expr : Expr, Number The rational expression representing the ``TransferFunction``. var : Symbol, optional Complex variable of the Laplace transform used by the polynomials of the transfer function. Raises ====== ValueError When ``expr`` is of type ``Number`` and optional parameter ``var`` is not passed. When ``expr`` has more than one variables and an optional parameter ``var`` is not passed. ZeroDivisionError When denominator of ``expr`` is zero or it has ``ComplexInfinity`` in its numerator. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy.physics.control.lti import TransferFunction >>> expr1 = (s + 5)/(3*s**2 + 2*s + 1) >>> tf1 = TransferFunction.from_rational_expression(expr1) >>> tf1 TransferFunction(s + 5, 3*s**2 + 2*s + 1, s) >>> expr2 = (a*p**3 - a*p**2 + s*p)/(p + a**2) # Expr with more than one variables >>> tf2 = TransferFunction.from_rational_expression(expr2, p) >>> tf2 TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p) In case of conflict between two or more variables in a expression, SymPy will raise a ``ValueError``, if ``var`` is not passed by the user. >>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1)) Traceback (most recent call last): ... ValueError: Conflicting values found for positional argument `var` ({a, s}). Specify it manually. This can be corrected by specifying the ``var`` parameter manually. >>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1), s) >>> tf TransferFunction(a*s + a, s**2 + s + 1, s) ``var`` also need to be specified when ``expr`` is a ``Number`` >>> tf3 = TransferFunction.from_rational_expression(10, s) >>> tf3 TransferFunction(10, 1, s) NrJrz Positional argument `var` not found in the TransferFunction defined. Specify it manually.zz Conflicting values found for positional argument `var` ({}). Specify it manually.r) rrrErrr+formatas_numer_denomrrComplexInfinityZeroDivisionError)rrrB _free_symbols_len_free_symbols_num_denr=r=rCfrom_rational_expressionts>   z)TransferFunction.from_rational_expressioncs|ddd}|ddd}fddtt|D}fddtt|D}tddt||D}tddt||D}|d krHtd |||S) aY Creates a new ``TransferFunction`` efficiently from a list of coefficients. Parameters ========== num_list : Sequence Sequence comprising of numerator coefficients. den_list : Sequence Sequence comprising of denominator coefficients. var : Symbol Complex variable of the Laplace transform used by the polynomials of the transfer function. Raises ====== ZeroDivisionError When the constructed denominator is zero. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction >>> num = [1, 0, 2] >>> den = [3, 2, 2, 1] >>> tf = TransferFunction.from_coeff_lists(num, den, s) >>> tf TransferFunction(s**2 + 2, 3*s**3 + 2*s**2 + 2*s + 1, s) # Create a Transfer Function with more than one variable >>> tf1 = TransferFunction.from_coeff_lists([p, 1], [2*p, 0, 4], s) >>> tf1 TransferFunction(p*s + 1, 2*p*s**2 + 4, s) NrVcg|]}|qSr=r=r>rOrr=rCrDr\z5TransferFunction.from_coeff_lists..crr=r=rrr=rCrDr\cs|] \}}||VqdSrr=r>coeff var_powerr=r=rCrrz4TransferFunction.from_coeff_lists..csrrr=rr=r=rCrrrr)rFrEsumrer)rnum_listden_listrBnum_var_powersden_var_powersrrr=rrCfrom_coeff_listss' z!TransferFunction.from_coeff_listsc CsDd}d}|D]}|||9}q|D]}|||9}q|||||S)a` Creates a new ``TransferFunction`` from given zeros, poles and gain. Parameters ========== zeros : Sequence Sequence comprising of zeros of transfer function. poles : Sequence Sequence comprising of poles of transfer function. gain : Number, Symbol, Expression A scalar value specifying gain of the model. var : Symbol Complex variable of the Laplace transform used by the polynomials of the transfer function. Examples ======== >>> from sympy.abc import s, p, k >>> from sympy.physics.control.lti import TransferFunction >>> zeros = [1, 2, 3] >>> poles = [6, 5, 4] >>> gain = 7 >>> tf = TransferFunction.from_zpk(zeros, poles, gain, s) >>> tf TransferFunction(7*(s - 3)*(s - 2)*(s - 1), (s - 6)*(s - 5)*(s - 4), s) # Create a Transfer Function with variable poles and zeros >>> tf1 = TransferFunction.from_zpk([p, k], [p + k, p - k], 2, s) >>> tf1 TransferFunction(2*(-k + s)*(-p + s), (-k - p + s)*(k - p + s), s) # Complex poles or zeros are acceptable >>> tf2 = TransferFunction.from_zpk([0], [1-1j, 1+1j, 2], -2, s) >>> tf2 TransferFunction(-2*s, (s - 2)*(s - 1.0 - 1.0*I)*(s - 1.0 + 1.0*I), s) rJr=) rr polesgainrBnum_polyden_polyzeropoler=r=rCfrom_zpks)zTransferFunction.from_zpkcC |jdS)a Returns the numerator polynomial of the transfer function. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction >>> G1 = TransferFunction(s**2 + p*s + 3, s - 4, s) >>> G1.num p*s + s**2 + 3 >>> G2 = TransferFunction((p + 5)*(p - 3), (p - 3)*(p + 1), p) >>> G2.num (p - 3)*(p + 5) rrrr=r=rCr_, zTransferFunction.numcCr)a Returns the denominator polynomial of the transfer function. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction >>> G1 = TransferFunction(s + 4, p**3 - 2*p + 4, s) >>> G1.den p**3 - 2*p + 4 >>> G2 = TransferFunction(3, 4, s) >>> G2.den 4 rJrrr=r=rCrb@rzTransferFunction.dencCr)a Returns the complex variable of the Laplace transform used by the polynomials of the transfer function. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G1.var p >>> G2 = TransferFunction(0, s - 5, s) >>> G2.var s rrr=r=rCrBTs zTransferFunction.varcCs<|j||}|j||}t|||j}||jkr|S|Sr)r_rrbr-rB)roldnewarg_numarg_denargnewr=r=rC _eval_subsiszTransferFunction._eval_subscCst|j||j||jSr)r-r_ _eval_evalfrbrB)rprecr=r=rCros   zTransferFunction._eval_evalfcKsBtt|jd|jdddd}|d|d}}t|||jS)NrJFevaluater r)r(rr_rbrr-rB)rrrfnum_den_r=r=rC_eval_simplifyus"zTransferFunction._eval_simplifycs,|jstdt|j|j}t|j|j}|}|}|||}dg||}dd}tfddt |Dg}t |dd} t |d} | | } | |} t |d} d| |d<|} g}| dkr||| | |d| d8} | dkslt|g}t|dg}t| | ||S)aM Returns the equivalent space space model of the transfer function model. The state space model will be returned in the controllable cannonical form. Unlike the space state to transfer function model conversion, the transfer function to state space model conversion is not unique. There can be multiple state space representations of a given transfer function model. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control import TransferFunction, StateSpace >>> tf = TransferFunction(s**2 + 1, s**3 + 2*s + 10, s) >>> tf.rewrite(StateSpace) StateSpace(Matrix([ [ 0, 1, 0], [ 0, 0, 1], [-10, -2, 0]]), Matrix([ [0], [0], [1]]), Matrix([[1, 0, 1]]), Matrix([[0]])) z!Transfer Function must be proper.rrJNcsg|] }d|dqS)rVrr=)r> coefficient den_coeffsr=rCrDsz@TransferFunction._eval_rewrite_as_StateSpace..) is_properrr%r_rBrbr)rarreversedr rrow_joincol_joinappendr5)rrrrrH num_coeffsdiffaa_matvertmatABrOCDr=rrC_eval_rewrite_as_StateSpacezs4        z,TransferFunction._eval_rewrite_as_StateSpacecCstt|jt|j|jS)aK Returns the transfer function with numerator and denominator in expanded form. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> G1 = TransferFunction((a - s)**2, (s**2 + a)**2, s) >>> G1.expand() TransferFunction(a**2 - 2*a*s + s**2, a**2 + 2*a*s**2 + s**4, s) >>> G2 = TransferFunction((p + 3*b)*(p - b), (p - b)*(p + 2*b), p) >>> G2.expand() TransferFunction(-3*b**2 + 2*b*p + p**2, -2*b**2 + b*p + p**2, p) )r-rr_rbrBrr=r=rCrszTransferFunction.expandcCs*t|jt|jddddd}t||jdS)a Computes the gain of the response as the frequency approaches zero. The DC gain is infinite for systems with pure integrators. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction(s + 3, s**2 - 9, s) >>> tf1.dc_gain() -1/3 >>> tf2 = TransferFunction(p**2, p - 3 + p**3, p) >>> tf2.dc_gain() 0 >>> tf3 = TransferFunction(a*p**2 - b, s + b, s) >>> tf3.dc_gain() (a*p**2 - b)/b >>> tf4 = TransferFunction(1, s, s) >>> tf4.dc_gain() oo rVFrr)rr_rrbr*rB)rmr=r=rCdc_gainszTransferFunction.dc_gaincCtt|j|j|jS)a  Returns the poles of a transfer function. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p) >>> tf1.poles() [-5, 1] >>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s) >>> tf2.poles() [I, I, -I, -I] >>> tf3 = TransferFunction(s**2, a*s + p, s) >>> tf3.poles() [-p/a] )rIr%rbrBrr=r=rCrzTransferFunction.polescCr)a Returns the zeros of a transfer function. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p) >>> tf1.zeros() [-3, 1] >>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s) >>> tf2.zeros() [1, 1] >>> tf3 = TransferFunction(s**2, a*s + p, s) >>> tf3.zeros() [0, 0] )rIr%r_rBrr=r=rCr rzTransferFunction.zeroscCs:|j|j|}|j|j|}t|||j}|S)aA Returns the system response at any point in the real or complex plane. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy.physics.control.lti import TransferFunction >>> from sympy import I >>> tf1 = TransferFunction(1, s**2 + 2*s + 1, s) >>> omega = 0.1 >>> tf1.eval_frequency(I*omega) 1/(0.99 + 0.2*I) >>> tf2 = TransferFunction(s**2, a*s + p, s) >>> tf2.eval_frequency(2) 4/(2*a + p) >>> tf2.eval_frequency(I*2) -4/(2*I*a + p) )r_rrBrbr-rr)rotherrrrr=r=rCeval_frequencyszTransferFunction.eval_frequencycCstdd|DS)ao Returns True if the transfer function is asymptotically stable; else False. This would not check the marginal or conditional stability of the system. Examples ======== >>> from sympy.abc import s, p, a >>> from sympy import symbols >>> from sympy.physics.control.lti import TransferFunction >>> q, r = symbols('q, r', negative=True) >>> tf1 = TransferFunction((1 - s)**2, (s + 1)**2, s) >>> tf1.is_stable() True >>> tf2 = TransferFunction((1 - p)**2, (s**2 + 1)**2, s) >>> tf2.is_stable() False >>> tf3 = TransferFunction(4, q*s - r, s) >>> tf3.is_stable() False >>> tf4 = TransferFunction(p + 1, a*p - s**2, p) >>> tf4.is_stable() is None # Not enough info about the symbols to determine stability True css|] }|djVqdSrN)r is_negative)r>rr=r=rCrDz-TransferFunction.is_stable..)rrrr=r=rC is_stable)szTransferFunction.is_stablecC~t|ttfr|j|jksttdt||St|tr6|j|jks)ttdt|j}t|g|RStd t |)N All the transfer functions should use the same complex variable of the Laplace transform.z)TransferFunction cannot be added with {}. rr-r.rBrr+r0rrrtyperrarg_listr=r=rC__add__F        zTransferFunction.__add__cC||Srr=rrr=r=rC__radd__XzTransferFunction.__radd__cCst|ttfr|j|jksttdt|| St|tr<|j|jks*ttdddt|jD}t|g|RStd t |)NrcSg|]}| qSr=r=rr=r=rCrDgrz,TransferFunction.__sub__..z0{} cannot be subtracted from a TransferFunction.rrr=r=rC__sub__[s       zTransferFunction.__sub__cC | |Srr=rr=r=rC__rsub__m zTransferFunction.__rsub__cCr)Nrz.TransferFunction cannot be multiplied with {}.) rr-r0rBrr+r.rrrrrr=r=rC__mul__przTransferFunction.__mul__cCsLt|tr|j|jksttdt|t|j|j|jSt|trt |j dkrt|j dtrt|j dttfr|j|jksGttd|j d|krVt ||j dSt|j dtrft |j dj n|j d}||j dkrwt ||S||vr| |nt |t|St |dkrt |g|RSt |t|Stdt|)NrrrrJz Both TransferFunction and Parallel should use the same complex variable of the Laplace transform.z)TransferFunction cannot be divided by {}.)rr-rBrr+r.rbr_r0rErr2rremoverrrrother_arg_listr=r=rC __truediv__s>          zTransferFunction.__truediv__cCszt|}|js td|tjurtdd|jS|dkr'|j||j|}}nt |}|j||j|}}t|||jS)NzExponent must be an integer.rJr) r is_Integerrrrqr-rBr_rbabs)rprrr=r=rC__pow__s zTransferFunction.__pow__cCst|j |j|jSr)r-r_rbrBrr=r=rC__neg__zTransferFunction.__neg__cCst|j|jt|j|jkS)a Returns True if degree of the numerator polynomial is less than or equal to degree of the denominator polynomial, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s) >>> tf1.is_proper False >>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*p + 2, p) >>> tf2.is_proper True r)r_rBrbrr=r=rCrzTransferFunction.is_propercCst|j|jt|j|jkS)a Returns True if degree of the numerator polynomial is strictly less than degree of the denominator polynomial, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf1.is_strictly_proper False >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tf2.is_strictly_proper True r2rr=r=rCis_strictly_properr3z#TransferFunction.is_strictly_propercCst|j|jt|j|jkS)a Returns True if degree of the numerator polynomial is equal to degree of the denominator polynomial, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf1.is_biproper True >>> tf2 = TransferFunction(p**2, p + a, p) >>> tf2.is_biproper False r2rr=r=rC is_biproperr3zTransferFunction.is_bipropercCs6|jdkrt|jt|jdddddSt|jdddS)a Converts a ``TransferFunction`` object to SymPy Expr. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction >>> from sympy import Expr >>> tf1 = TransferFunction(s, a*s**2 + 1, s) >>> tf1.to_expr() s/(a*s**2 + 1) >>> isinstance(_, Expr) True >>> tf2 = TransferFunction(1, (p + 3*b)*(b - p), p) >>> tf2.to_expr() 1/((b - p)*(3*b + p)) >>> tf3 = TransferFunction((s - 2)*(s - 3), (s - 1)*(s - 2)*(s - 3), s) >>> tf3.to_expr() ((s - 3)*(s - 2))/(((s - 3)*(s - 2)*(s - 1))) rJrVFr)r_rrrbrr=r=rCrs zTransferFunction.to_exprr)&rrrrrrrrrrr_rbrBrrrr rr rr rrrr r#r%r'__rmul__r+ __rtruediv__r/r0rr4r5rrr=r=rrCr-sV : Q 3 1   :#   r-cCs8g}|D]}t||r||jq||qt|Sr)rextendrrtuple)r_cls temp_argsrsr=r=rC _flatten_argss   r<cCs@i}g}|D]}t}|||<|||i}||q||fSr)rrr)_argrB dummy_dictdummy_arg_listrs_s dummy_argr=r=rC _dummify_args!s rBcseZdZdZddfdd ZeddZdd Zd d Ze d d Z e Z e ddZ ddZ e ddZddZddZddZeddZeddZeddZZS) r.a A class for representing a series configuration of SISO systems. Parameters ========== args : SISOLinearTimeInvariant SISO systems in a series configuration. evaluate : Boolean, Keyword When passed ``True``, returns the equivalent ``Series(*args).doit()``. Set to ``False`` by default. Raises ====== ValueError When no argument is passed. ``var`` attribute is not same for every system. TypeError Any of the passed ``*args`` has unsupported type A combination of SISO and MIMO systems is passed. There should be homogeneity in the type of systems passed, SISO in this case. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Series, Parallel >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tf3 = TransferFunction(p**2, p + s, s) >>> S1 = Series(tf1, tf2) >>> S1 Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)) >>> S1.var s >>> S2 = Series(tf2, Parallel(tf3, -tf1)) >>> S2 Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Parallel(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s))) >>> S2.var s >>> S3 = Series(Parallel(tf1, tf2), Parallel(tf2, tf3)) >>> S3 Series(Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s))) >>> S3.var s You can get the resultant transfer function by using ``.doit()`` method: >>> S3 = Series(tf1, tf2, -tf3) >>> S3.doit() TransferFunction(-p**2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(p + s)*(s**4 + 5*s + 6), s) >>> S4 = Series(tf2, Parallel(tf1, -tf3)) >>> S4.doit() TransferFunction((s**3 - 2)*(-p**2*(-p + s) + (p + s)*(a*p**2 + b*s)), (-p + s)*(p + s)*(s**4 + 5*s + 6), s) Notes ===== All the transfer functions should use the same complex variable ``var`` of the Laplace transform. See Also ======== MIMOSeries, Parallel, TransferFunction, Feedback Frc8t|t}||tj|g|R}|r|S|Sr)r<r.rrrdoitrrrobjrr=rCrv  zSeries.__new__cC |jdjS)a Returns the complex variable used by all the transfer functions. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, Series, Parallel >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G2 = TransferFunction(p, 4 - p, p) >>> G3 = TransferFunction(0, p**4 - 1, p) >>> Series(G1, G2).var p >>> Series(-G3, Parallel(G1, G2)).var p rrrBrr=r=rCrB~ z Series.varcKsJdd|jD}dd|jD}t|ddi}t|ddi}t|||jS)a Returns the resultant transfer function obtained after evaluating the transfer functions in series configuration. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Series >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> Series(tf2, tf1).doit() TransferFunction((s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s) >>> Series(-tf1, -tf2).doit() TransferFunction((2 - s**3)*(-a*p**2 - b*s), (-p + s)*(s**4 + 5*s + 6), s) cs|]}|jVqdSr)rDr_rr=r=rCrzSeries.doit..csrKr)rDrbrr=r=rCrrLrT)rrr-rB)rhints_num_arg_den_argres_numres_denr=r=rCrDs z Series.doitcO|SrrDrrrr=r=rC!_eval_rewrite_as_TransferFunctionr!z(Series._eval_rewrite_as_TransferFunctioncC.t|trt|j}t|g|RSt||Sr)rr0rrrr=r=rCr   zSeries.__add__cC || Srr=rr=r=rCr# zSeries.__sub__cCr$rr=rr=r=rCr%r&zSeries.__rsub__cCt|j}tg||RSr)rrr.rr=r=rCr' zSeries.__mul__cCst|trtg|jt|j|j|jRSt|tr)|t}|t}||St|trt |jdkrt|jdtrt|jdtr|j|jksQt t dt |j}t |jdj}t ||A}t |dkrrt||jdSt |dkrt|g|RSt|t|St d)NrrrJrz-This transfer function expression is invalid.)rr-r.rrbr_rBrewriter0rErr+setrr2)rrtf_selftf_other self_arg_listr*resr=r=rCr+s, "         zSeries.__truediv__cCttdd|j|SNrVrJr.r-rBrr=r=rCr0r1zSeries.__neg__cCtdd|jDddiS)'Returns the equivalent ``Expr`` object.cs|]}|VqdSrrrr=r=rCrz!Series.to_expr..rF)rrrr=r=rCrzSeries.to_exprcC |jS)a Returns True if degree of the numerator polynomial of the resultant transfer function is less than or equal to degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Series >>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s) >>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s) >>> tf3 = TransferFunction(s, s**2 + s + 1, s) >>> S1 = Series(-tf2, tf1) >>> S1.is_proper False >>> S2 = Series(tf1, tf2, tf3) >>> S2.is_proper True rDrrr=r=rCr zSeries.is_propercCrk)a Returns True if degree of the numerator polynomial of the resultant transfer function is strictly less than degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Series >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**2 + 5*s + 6, s) >>> tf3 = TransferFunction(1, s**2 + s + 1, s) >>> S1 = Series(tf1, tf2) >>> S1.is_strictly_proper False >>> S2 = Series(tf1, tf2, tf3) >>> S2.is_strictly_proper True rDr4rr=r=rCr4rmzSeries.is_strictly_propercCrk)a Returns True if degree of the numerator polynomial of the resultant transfer function is equal to degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Series >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(p, s**2, s) >>> tf3 = TransferFunction(s**2, 1, s) >>> S1 = Series(tf1, -tf2) >>> S1.is_biproper False >>> S2 = Series(tf2, tf3) >>> S2.is_biproper True rDr5rr=r=rCr5rmzSeries.is_biproper)rrrrrrrBrDrUrrr r#r%r'r+r0rrr4r5rr=r=rrCr..s0G      r.cs"tfddttdDS)z6To check whether shapes are compatible for matrix mul.c3s(|]}|j|djkVqdS)rJN num_outputs num_inputsrrr=rCr6s&z&_mat_mul_compatible..rJ)rrFrErr=rrC_mat_mul_compatible4s"rscseZdZdZddfdd ZeddZedd Zed d Zed d Z dddZ ddZ e ddZ e Ze ddZddZe ddZddZZS)r/a~ A class for representing a series configuration of MIMO systems. Parameters ========== args : MIMOLinearTimeInvariant MIMO systems in a series configuration. evaluate : Boolean, Keyword When passed ``True``, returns the equivalent ``MIMOSeries(*args).doit()``. Set to ``False`` by default. Raises ====== ValueError When no argument is passed. ``var`` attribute is not same for every system. ``num_outputs`` of the MIMO system is not equal to the ``num_inputs`` of its adjacent MIMO system. (Matrix multiplication constraint, basically) TypeError Any of the passed ``*args`` has unsupported type A combination of SISO and MIMO systems is passed. There should be homogeneity in the type of systems passed, MIMO in this case. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import MIMOSeries, TransferFunctionMatrix >>> from sympy import Matrix, pprint >>> mat_a = Matrix([[5*s], [5]]) # 2 Outputs 1 Input >>> mat_b = Matrix([[5, 1/(6*s**2)]]) # 1 Output 2 Inputs >>> mat_c = Matrix([[1, s], [5/s, 1]]) # 2 Outputs 2 Inputs >>> tfm_a = TransferFunctionMatrix.from_Matrix(mat_a, s) >>> tfm_b = TransferFunctionMatrix.from_Matrix(mat_b, s) >>> tfm_c = TransferFunctionMatrix.from_Matrix(mat_c, s) >>> MIMOSeries(tfm_c, tfm_b, tfm_a) MIMOSeries(TransferFunctionMatrix(((TransferFunction(1, 1, s), TransferFunction(s, 1, s)), (TransferFunction(5, s, s), TransferFunction(1, 1, s)))), TransferFunctionMatrix(((TransferFunction(5, 1, s), TransferFunction(1, 6*s**2, s)),)), TransferFunctionMatrix(((TransferFunction(5*s, 1, s),), (TransferFunction(5, 1, s),)))) >>> pprint(_, use_unicode=False) # For Better Visualization [5*s] [1 s] [---] [5 1 ] [- -] [ 1 ] [- ----] [1 1] [ ] *[1 2] *[ ] [ 5 ] [ 6*s ]{t} [5 1] [ - ] [- -] [ 1 ]{t} [s 1]{t} >>> MIMOSeries(tfm_c, tfm_b, tfm_a).doit() TransferFunctionMatrix(((TransferFunction(150*s**4 + 25*s, 6*s**3, s), TransferFunction(150*s**4 + 5*s, 6*s**2, s)), (TransferFunction(150*s**3 + 25, 6*s**3, s), TransferFunction(150*s**3 + 5, 6*s**2, s)))) >>> pprint(_, use_unicode=False) # (2 Inputs -A-> 2 Outputs) -> (2 Inputs -B-> 1 Output) -> (1 Input -C-> 2 Outputs) is equivalent to (2 Inputs -Series Equivalent-> 2 Outputs). [ 4 4 ] [150*s + 25*s 150*s + 5*s] [------------- ------------] [ 3 2 ] [ 6*s 6*s ] [ ] [ 3 3 ] [ 150*s + 25 150*s + 5 ] [ ----------- ---------- ] [ 3 2 ] [ 6*s 6*s ]{t} Notes ===== All the transfer function matrices should use the same complex variable ``var`` of the Laplace transform. ``MIMOSeries(A, B)`` is not equivalent to ``A*B``. It is always in the reverse order, that is ``B*A``. See Also ======== Series, MIMOParallel FrcsD||t|rtj|g|R}nttd|r |S|S)Nz Number of input signals do not match the number of output signals of adjacent systems for some args.)rrsrrrr+rDrErr=rCrs  zMIMOSeries.__new__cCrH)aL Returns the complex variable used by all the transfer functions. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G2 = TransferFunction(p, 4 - p, p) >>> G3 = TransferFunction(0, p**4 - 1, p) >>> tfm_1 = TransferFunctionMatrix([[G1, G2, G3]]) >>> tfm_2 = TransferFunctionMatrix([[G1], [G2], [G3]]) >>> MIMOSeries(tfm_2, tfm_1).var p rrIrr=r=rCrBrJzMIMOSeries.varcCrH)z9Returns the number of input signals of the series system.rrrrrr=r=rCrr zMIMOSeries.num_inputscCrH)z:Returns the number of output signals of the series system.rVrrqrr=r=rCrqruzMIMOSeries.num_outputscC |j|jfSz0Returns the shape of the equivalent MIMO system.rprr=r=rCshaperuzMIMOSeries.shapecKsjddt|jD}|rt|ddi}t||jSt||j\}}t|ddi}t||j}||S)ap Returns the resultant transfer function matrix obtained after evaluating the MIMO systems arranged in a series configuration. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tfm1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf2]]) >>> tfm2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf1]]) >>> MIMOSeries(tfm2, tfm1).doit() TransferFunctionMatrix(((TransferFunction(2*(-p + s)*(s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)**2*(s**4 + 5*s + 6)**2, s), TransferFunction((-p + s)**2*(s**3 - 2)*(a*p**2 + b*s) + (-p + s)*(a*p**2 + b*s)**2*(s**4 + 5*s + 6), (-p + s)**3*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2)**2*(s**4 + 5*s + 6) + (s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6)**2, (-p + s)*(s**4 + 5*s + 6)**3, s), TransferFunction(2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s)))) csrKrrD _expr_matrr=r=rCrrLz"MIMOSeries.doit..rT)rrr#r4 from_MatrixrBrBr)rr(rr=ra _dummy_args _dummy_dicttemp_tfmr=r=rCrDs zMIMOSeries.doitcOrRrrSrTr=r=rC'_eval_rewrite_as_TransferFunctionMatrixr!z2MIMOSeries._eval_rewrite_as_TransferFunctionMatrixcCrVrrr1rrrr=r=rCrrWzMIMOSeries.__add__cCrXrr=rr=r=rCr#rYzMIMOSeries.__sub__cCr$rr=rr=r=rCr%r&zMIMOSeries.__rsub__cCsJt|trt|j}t|j}tg||RSt|j}t|g|RSrrr/rr)rrr`r*rr=r=rCr's    zMIMOSeries.__mul__cCs t|j}|d |d<t|S)Nr)rrr/rrr=r=rCr0s zMIMOSeries.__neg__)FrrrrrrrBrrrqryrDrrrr r#r%r'r0rr=r=rrCr/9s,P         r/cseZdZdZddfdd ZeddZdd Zd d Ze d d Z e Z e ddZ ddZ e ddZddZddZeddZeddZeddZZS)r0a A class for representing a parallel configuration of SISO systems. Parameters ========== args : SISOLinearTimeInvariant SISO systems in a parallel arrangement. evaluate : Boolean, Keyword When passed ``True``, returns the equivalent ``Parallel(*args).doit()``. Set to ``False`` by default. Raises ====== ValueError When no argument is passed. ``var`` attribute is not same for every system. TypeError Any of the passed ``*args`` has unsupported type A combination of SISO and MIMO systems is passed. There should be homogeneity in the type of systems passed. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Parallel, Series >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tf3 = TransferFunction(p**2, p + s, s) >>> P1 = Parallel(tf1, tf2) >>> P1 Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)) >>> P1.var s >>> P2 = Parallel(tf2, Series(tf3, -tf1)) >>> P2 Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Series(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s))) >>> P2.var s >>> P3 = Parallel(Series(tf1, tf2), Series(tf2, tf3)) >>> P3 Parallel(Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s))) >>> P3.var s You can get the resultant transfer function by using ``.doit()`` method: >>> Parallel(tf1, tf2, -tf3).doit() TransferFunction(-p**2*(-p + s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2) + (p + s)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(p + s)*(s**4 + 5*s + 6), s) >>> Parallel(tf2, Series(tf1, -tf3)).doit() TransferFunction(-p**2*(a*p**2 + b*s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2), (-p + s)*(p + s)*(s**4 + 5*s + 6), s) Notes ===== All the transfer functions should use the same complex variable ``var`` of the Laplace transform. See Also ======== Series, TransferFunction, Feedback FrcrCr)r<r0rrrrDrErr=rCrErGzParallel.__new__cCrH)a Returns the complex variable used by all the transfer functions. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, Parallel, Series >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G2 = TransferFunction(p, 4 - p, p) >>> G3 = TransferFunction(0, p**4 - 1, p) >>> Parallel(G1, G2).var p >>> Parallel(-G3, Series(G1, G2)).var p rrIrr=r=rCrBMrJz Parallel.varcKs0dd|jD}t|}tg||jRS)a Returns the resultant transfer function obtained after evaluating the transfer functions in parallel configuration. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Parallel >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> Parallel(tf2, tf1).doit() TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s) >>> Parallel(-tf1, -tf2).doit() TransferFunction((2 - s**3)*(-p + s) + (-a*p**2 - b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s) css|] }|VqdSrrDrrr=r=rCrurz Parallel.doit..)rrrr-rBrrMr=rar=r=rCrDbs z Parallel.doitcOrRrrSrTr=r=rCrUyr!z*Parallel._eval_rewrite_as_TransferFunctioncCrZr)rrr0rrr`r=r=rCr|r[zParallel.__add__cCrXrr=rr=r=rCr#rYzParallel.__sub__cCr$rr=rr=r=rCr%r&zParallel.__rsub__cCrVr)rr.rrrr=r=rCr'rWzParallel.__mul__cCrbrcrdrr=r=rCr0r1zParallel.__neg__cCre)rfcsrgrrhrr=r=rCrriz#Parallel.to_expr..rF)rrrr=r=rCrrjzParallel.to_exprcCrk)a Returns True if degree of the numerator polynomial of the resultant transfer function is less than or equal to degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Parallel >>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s) >>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s) >>> tf3 = TransferFunction(s, s**2 + s + 1, s) >>> P1 = Parallel(-tf2, tf1) >>> P1.is_proper False >>> P2 = Parallel(tf2, tf3) >>> P2.is_proper True rlrr=r=rCrrmzParallel.is_propercCrk)a Returns True if degree of the numerator polynomial of the resultant transfer function is strictly less than degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Parallel >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tf3 = TransferFunction(s, s**2 + s + 1, s) >>> P1 = Parallel(tf1, tf2) >>> P1.is_strictly_proper False >>> P2 = Parallel(tf2, tf3) >>> P2.is_strictly_proper True rnrr=r=rCr4rmzParallel.is_strictly_propercCrk)a Returns True if degree of the numerator polynomial of the resultant transfer function is equal to degree of the denominator polynomial of the same, else False. Examples ======== >>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, Parallel >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(p**2, p + s, s) >>> tf3 = TransferFunction(s, s**2 + s + 1, s) >>> P1 = Parallel(tf1, -tf2) >>> P1.is_biproper True >>> P2 = Parallel(tf2, tf3) >>> P2.is_biproper False rorr=r=rCr5rmzParallel.is_biproper)rrrrrrrBrDrUrrr r#r%r'r0rrr4r5rr=r=rrCr0s.E      r0cseZdZdZddfdd ZeddZedd Zed d Zed d Z ddZ ddZ e ddZ e Ze ddZddZe ddZddZZS)r1a A class for representing a parallel configuration of MIMO systems. Parameters ========== args : MIMOLinearTimeInvariant MIMO Systems in a parallel arrangement. evaluate : Boolean, Keyword When passed ``True``, returns the equivalent ``MIMOParallel(*args).doit()``. Set to ``False`` by default. Raises ====== ValueError When no argument is passed. ``var`` attribute is not same for every system. All MIMO systems passed do not have same shape. TypeError Any of the passed ``*args`` has unsupported type A combination of SISO and MIMO systems is passed. There should be homogeneity in the type of systems passed, MIMO in this case. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOParallel >>> from sympy import Matrix, pprint >>> expr_1 = 1/s >>> expr_2 = s/(s**2-1) >>> expr_3 = (2 + s)/(s**2 - 1) >>> expr_4 = 5 >>> tfm_a = TransferFunctionMatrix.from_Matrix(Matrix([[expr_1, expr_2], [expr_3, expr_4]]), s) >>> tfm_b = TransferFunctionMatrix.from_Matrix(Matrix([[expr_2, expr_1], [expr_4, expr_3]]), s) >>> tfm_c = TransferFunctionMatrix.from_Matrix(Matrix([[expr_3, expr_4], [expr_1, expr_2]]), s) >>> MIMOParallel(tfm_a, tfm_b, tfm_c) MIMOParallel(TransferFunctionMatrix(((TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s)), (TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)))), TransferFunctionMatrix(((TransferFunction(s, s**2 - 1, s), TransferFunction(1, s, s)), (TransferFunction(5, 1, s), TransferFunction(s + 2, s**2 - 1, s)))), TransferFunctionMatrix(((TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)), (TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s))))) >>> pprint(_, use_unicode=False) # For Better Visualization [ 1 s ] [ s 1 ] [s + 2 5 ] [ - ------] [------ - ] [------ - ] [ s 2 ] [ 2 s ] [ 2 1 ] [ s - 1] [s - 1 ] [s - 1 ] [ ] + [ ] + [ ] [s + 2 5 ] [ 5 s + 2 ] [ 1 s ] [------ - ] [ - ------] [ - ------] [ 2 1 ] [ 1 2 ] [ s 2 ] [s - 1 ]{t} [ s - 1]{t} [ s - 1]{t} >>> MIMOParallel(tfm_a, tfm_b, tfm_c).doit() TransferFunctionMatrix(((TransferFunction(s**2 + s*(2*s + 2) - 1, s*(s**2 - 1), s), TransferFunction(2*s**2 + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s)), (TransferFunction(s**2 + s*(s + 2) + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s), TransferFunction(5*s**2 + 2*s - 3, s**2 - 1, s)))) >>> pprint(_, use_unicode=False) [ 2 2 / 2 \ ] [ s + s*(2*s + 2) - 1 2*s + 5*s*\s - 1/ - 1] [ -------------------- -----------------------] [ / 2 \ / 2 \ ] [ s*\s - 1/ s*\s - 1/ ] [ ] [ 2 / 2 \ 2 ] [s + s*(s + 2) + 5*s*\s - 1/ - 1 5*s + 2*s - 3 ] [--------------------------------- -------------- ] [ / 2 \ 2 ] [ s*\s - 1/ s - 1 ]{t} Notes ===== All the transfer function matrices should use the same complex variable ``var`` of the Laplace transform. See Also ======== Parallel, MIMOSeries FrcsVtt|tfddDrtdtj|gR}|r)|S|S)Nc3s |] }|jdjkVqdSr)ryrrr=rCr>sz'MIMOParallel.__new__..z#Shape of all the args is not equal.)r<r1ranyrrrrDrErrrCr8s  zMIMOParallel.__new__cCrH)a Returns the complex variable used by all the systems. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOParallel >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G2 = TransferFunction(p, 4 - p, p) >>> G3 = TransferFunction(0, p**4 - 1, p) >>> G4 = TransferFunction(p**2, p**2 - 1, p) >>> tfm_a = TransferFunctionMatrix([[G1, G2], [G3, G4]]) >>> tfm_b = TransferFunctionMatrix([[G2, G1], [G4, G3]]) >>> MIMOParallel(tfm_a, tfm_b).var p rrIrr=r=rCrBEs zMIMOParallel.varcCrH)z;Returns the number of input signals of the parallel system.rrtrr=r=rCrr[ruzMIMOParallel.num_inputscCrH)z>> from sympy.abc import s, p, a, b >>> from sympy.physics.control.lti import TransferFunction, MIMOParallel, TransferFunctionMatrix >>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s) >>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s) >>> tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]]) >>> tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]]) >>> MIMOParallel(tfm_1, tfm_2).doit() TransferFunctionMatrix(((TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)))) csrKrrzrr=r=rCr|rLz$MIMOParallel.doit..rT)rr$r4r|rBrr=r=rCrDjszMIMOParallel.doitcOrRrrSrTr=r=rCrr!z4MIMOParallel._eval_rewrite_as_TransferFunctionMatrixcCrZrrrr1rr=r=rCrr[zMIMOParallel.__add__cCrXrr=rr=r=rCr#rYzMIMOParallel.__sub__cCr$rr=rr=r=rCr%r&zMIMOParallel.__rsub__cCs0t|trt|j}tg||RSt||Srrrr=r=rCr's   zMIMOParallel.__mul__cCsddt|jD}t|S)NcSr"r=r=rr=r=rCrDrz(MIMOParallel.__neg__..rrr=r=rCr0szMIMOParallel.__neg__rr=r=rrCr1s,P       r1cseZdZdZdfdd ZeddZedd Zed d Zed d Z eddZ eddZ eddZ dddZ ddZddZddZZS)r2a A class for representing closed-loop feedback interconnection between two SISO input/output systems. The first argument, ``sys1``, is the feedforward part of the closed-loop system or in simple words, the dynamical model representing the process to be controlled. The second argument, ``sys2``, is the feedback system and controls the fed back signal to ``sys1``. Both ``sys1`` and ``sys2`` can either be ``Series`` or ``TransferFunction`` objects. Parameters ========== sys1 : Series, TransferFunction The feedforward path system. sys2 : Series, TransferFunction, optional The feedback path system (often a feedback controller). It is the model sitting on the feedback path. If not specified explicitly, the sys2 is assumed to be unit (1.0) transfer function. sign : int, optional The sign of feedback. Can either be ``1`` (for positive feedback) or ``-1`` (for negative feedback). Default value is `-1`. Raises ====== ValueError When ``sys1`` and ``sys2`` are not using the same complex variable of the Laplace transform. When a combination of ``sys1`` and ``sys2`` yields zero denominator. TypeError When either ``sys1`` or ``sys2`` is not a ``Series`` or a ``TransferFunction`` object. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> controller = TransferFunction(5*s - 10, s + 7, s) >>> F1 = Feedback(plant, controller) >>> F1 Feedback(TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1) >>> F1.var s >>> F1.args (TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1) You can get the feedforward and feedback path systems by using ``.sys1`` and ``.sys2`` respectively. >>> F1.sys1 TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> F1.sys2 TransferFunction(5*s - 10, s + 7, s) You can get the resultant closed loop transfer function obtained by negative feedback interconnection using ``.doit()`` method. >>> F1.doit() TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s) >>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s) >>> C = TransferFunction(5*s + 10, s + 10, s) >>> F2 = Feedback(G*C, TransferFunction(1, 1, s)) >>> F2.doit() TransferFunction((s + 10)*(5*s + 10)*(s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s + 10)*((s + 10)*(s**2 + 2*s + 3) + (5*s + 10)*(2*s**2 + 5*s + 1))*(s**2 + 2*s + 3), s) To negate a ``Feedback`` object, the ``-`` operator can be prepended: >>> -F1 Feedback(TransferFunction(-3*s**2 - 7*s + 3, s**2 - 4*s + 2, s), TransferFunction(10 - 5*s, s + 7, s), -1) >>> -F2 Feedback(Series(TransferFunction(-1, 1, s), TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s), TransferFunction(5*s + 10, s + 10, s)), TransferFunction(-1, 1, s), -1) See Also ======== MIMOFeedback, Series, Parallel NrVcs|s tdd|j}t|tttfrt|tttfstd|dvr'ttdt| |  |kr8td|j|jkrDttdt t| |||t |S)NrJz2Unsupported type for `sys1` or `sys2` of Feedback.rVrJ Unsupported type for feedback. `sign` arg should either be 1 (positive feedback loop) or -1 (negative feedback loop).z1The equivalent system will have zero denominator.b Both `sys1` and `sys2` should be using the same complex variable.)r-rBrr.r2rrr+rrsimplifyrrrrsys1sys2signrr=rCrs   zFeedback.__new__cCr)a Returns the feedforward system of the feedback interconnection. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> controller = TransferFunction(5*s - 10, s + 7, s) >>> F1 = Feedback(plant, controller) >>> F1.sys1 TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p) >>> C = TransferFunction(5*p + 10, p + 10, p) >>> P = TransferFunction(1 - s, p + 2, p) >>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P) >>> F2.sys1 TransferFunction(1, 1, p) rrrr=r=rCr rmz Feedback.sys1cCr)ao Returns the feedback controller of the feedback interconnection. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> controller = TransferFunction(5*s - 10, s + 7, s) >>> F1 = Feedback(plant, controller) >>> F1.sys2 TransferFunction(5*s - 10, s + 7, s) >>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p) >>> C = TransferFunction(5*p + 10, p + 10, p) >>> P = TransferFunction(1 - s, p + 2, p) >>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P) >>> F2.sys2 Series(TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p), TransferFunction(5*p + 10, p + 10, p), TransferFunction(1 - s, p + 2, p)) rJrrr=r=rCr( rmz Feedback.sys2cC|jjS)a Returns the complex variable of the Laplace transform used by all the transfer functions involved in the feedback interconnection. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> controller = TransferFunction(5*s - 10, s + 7, s) >>> F1 = Feedback(plant, controller) >>> F1.var s >>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p) >>> C = TransferFunction(5*p + 10, p + 10, p) >>> P = TransferFunction(1 - s, p + 2, p) >>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P) >>> F2.var p rrBrr=r=rCrBA sz Feedback.varcCr)zn Returns the type of MIMO Feedback model. ``1`` for Positive and ``-1`` for Negative. rrrr=r=rCr[  z Feedback.signcCr)zK Returns the numerator of the closed loop feedback system. )rrr=r=rCr_c sz Feedback.numcCsjtdd|j}t|jtrt|jjn|jg}|jdkr)t|t|j g|R St|t|j g|RS)zL Returns the denominator of the closed loop feedback model. rJ) r-rBrrr.rrrr0r)runitrr=r=rCrbj s   z Feedback.dencCs"dd|j|j|jS)a Returns the sensitivity function of the feedback loop. Sensitivity of a Feedback system is the ratio of change in the open loop gain to the change in the closed loop gain. .. note:: This method would not return the complementary sensitivity function. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> C = TransferFunction(5*p + 10, p + 10, p) >>> P = TransferFunction(1 - p, p + 2, p) >>> F_1 = Feedback(P, C) >>> F_1.sensitivity 1/((1 - p)*(5*p + 10)/((p + 2)*(p + 10)) + 1) rJ)rrrrrr=r=rC sensitivityu s"zFeedback.sensitivityFc Kst|jtr t|jjn|jg}|jtdd|jj}}|jdkr2t |t|j g|R}nt |t|j g|R }t|j |j |j |j |j}|rV| }|r\|}|S)a Returns the resultant transfer function obtained by the feedback interconnection. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s) >>> controller = TransferFunction(5*s - 10, s + 7, s) >>> F1 = Feedback(plant, controller) >>> F1.doit() TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s) >>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s) >>> F2 = Feedback(G, TransferFunction(1, 1, s)) >>> F2.doit() TransferFunction((s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s**2 + 2*s + 3)*(3*s**2 + 7*s + 4), s) Use kwarg ``expand=True`` to expand the resultant transfer function. Use ``cancel=True`` to cancel out the common terms in numerator and denominator. >>> F2.doit(cancel=True, expand=True) TransferFunction(2*s**2 + 5*s + 1, 3*s**2 + 7*s + 4, s) >>> F2.doit(expand=True) TransferFunction(2*s**4 + 9*s**3 + 17*s**2 + 17*s + 3, 3*s**4 + 13*s**3 + 27*s**2 + 29*s + 12, s) rJrV)rrr.rrrDr-rBrr0rr_rbrr) rr(rrMrF_nrF_d _resultant_tfr=r=rCrD s  z Feedback.doitcKrRrrS)rr_rbrrr=r=rCrU r!z*Feedback._eval_rewrite_as_TransferFunctioncC |S)a Converts a ``Feedback`` object to SymPy Expr. Examples ======== >>> from sympy.abc import s, a, b >>> from sympy.physics.control.lti import TransferFunction, Feedback >>> from sympy import Expr >>> tf1 = TransferFunction(a+s, 1, s) >>> tf2 = TransferFunction(b+s, 1, s) >>> fd1 = Feedback(tf1, tf2) >>> fd1.to_expr() (a + s)/((a + s)*(b + s) + 1) >>> isinstance(_, Expr) True rrr=r=rCr rJzFeedback.to_exprcCt|j |j |jSr)r2rrrrr=r=rCr0 zFeedback.__neg__r)FF)rrrrrrrrrBrr_rbrrDrUrr0rr=r=rrCr2s*V        0r2cCs2t|j||j|j}|}|dkS)zV Checks whether a given pair of MIMO systems passed is invertible or not. r)rrqrDr{det)rbr_mat_detr=r=rC_is_invertible s"rcsxeZdZdZdfdd ZeddZeddZed d Zed d Z ed dZ dddZ ddZ ddZ ZS)r3a A class for representing closed-loop feedback interconnection between two MIMO input/output systems. Parameters ========== sys1 : MIMOSeries, TransferFunctionMatrix The MIMO system placed on the feedforward path. sys2 : MIMOSeries, TransferFunctionMatrix The system placed on the feedback path (often a feedback controller). sign : int, optional The sign of feedback. Can either be ``1`` (for positive feedback) or ``-1`` (for negative feedback). Default value is `-1`. Raises ====== ValueError When ``sys1`` and ``sys2`` are not using the same complex variable of the Laplace transform. Forward path model should have an equal number of inputs/outputs to the feedback path outputs/inputs. When product of ``sys1`` and ``sys2`` is not a square matrix. When the equivalent MIMO system is not invertible. TypeError When either ``sys1`` or ``sys2`` is not a ``MIMOSeries`` or a ``TransferFunctionMatrix`` object. Examples ======== >>> from sympy import Matrix, pprint >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOFeedback >>> plant_mat = Matrix([[1, 1/s], [0, 1]]) >>> controller_mat = Matrix([[10, 0], [0, 10]]) # Constant Gain >>> plant = TransferFunctionMatrix.from_Matrix(plant_mat, s) >>> controller = TransferFunctionMatrix.from_Matrix(controller_mat, s) >>> feedback = MIMOFeedback(plant, controller) # Negative Feedback (default) >>> pprint(feedback, use_unicode=False) / [1 1] [10 0 ] \-1 [1 1] | [- -] [-- - ] | [- -] | [1 s] [1 1 ] | [1 s] |I + [ ] *[ ] | * [ ] | [0 1] [0 10] | [0 1] | [- -] [- --] | [- -] \ [1 1]{t} [1 1 ]{t}/ [1 1]{t} To get the equivalent system matrix, use either ``doit`` or ``rewrite`` method. >>> pprint(feedback.doit(), use_unicode=False) [1 1 ] [-- -----] [11 121*s] [ ] [0 1 ] [- -- ] [1 11 ]{t} To negate the ``MIMOFeedback`` object, use ``-`` operator. >>> neg_feedback = -feedback >>> pprint(neg_feedback.doit(), use_unicode=False) [-1 -1 ] [--- -----] [11 121*s] [ ] [ 0 -1 ] [ - --- ] [ 1 11 ]{t} See Also ======== Feedback, MIMOSeries, MIMOParallel rVcst|ttfrt|ttfstd|j|jks|j|jkr$ttd|dvr.ttdt|||s8td|j |j krDttdt |||t |S)Nz7Unsupported type for `sys1` or `sys2` of MIMO Feedback.zY Product of `sys1` and `sys2` must yield a square matrix.rrzNon-Invertible system inputted.r) rr4r/rrrrqrr+rrBrrrrrr=rCr= s        zMIMOFeedback.__new__cCr)a Returns the system placed on the feedforward path of the MIMO feedback interconnection. Examples ======== >>> from sympy import pprint >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback >>> tf1 = TransferFunction(s**2 + s + 1, s**2 - s + 1, s) >>> tf2 = TransferFunction(1, s, s) >>> tf3 = TransferFunction(1, 1, s) >>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]]) >>> sys2 = TransferFunctionMatrix([[tf3, tf3], [tf3, tf2]]) >>> F_1 = MIMOFeedback(sys1, sys2, 1) >>> F_1.sys1 TransferFunctionMatrix(((TransferFunction(s**2 + s + 1, s**2 - s + 1, s), TransferFunction(1, s, s)), (TransferFunction(1, s, s), TransferFunction(s**2 + s + 1, s**2 - s + 1, s)))) >>> pprint(_, use_unicode=False) [ 2 ] [s + s + 1 1 ] [---------- - ] [ 2 s ] [s - s + 1 ] [ ] [ 2 ] [ 1 s + s + 1] [ - ----------] [ s 2 ] [ s - s + 1]{t} rrrr=r=rCrW s !zMIMOFeedback.sys1cCr)a+ Returns the feedback controller of the MIMO feedback interconnection. Examples ======== >>> from sympy import pprint >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback >>> tf1 = TransferFunction(s**2, s**3 - s + 1, s) >>> tf2 = TransferFunction(1, s, s) >>> tf3 = TransferFunction(1, 1, s) >>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]]) >>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]]) >>> F_1 = MIMOFeedback(sys1, sys2) >>> F_1.sys2 TransferFunctionMatrix(((TransferFunction(s**2, s**3 - s + 1, s), TransferFunction(1, 1, s)), (TransferFunction(1, 1, s), TransferFunction(1, s, s)))) >>> pprint(_, use_unicode=False) [ 2 ] [ s 1] [---------- -] [ 3 1] [s - s + 1 ] [ ] [ 1 1] [ - -] [ 1 s]{t} rJrrr=r=rCrz s zMIMOFeedback.sys2cCr)a Returns the complex variable of the Laplace transform used by all the transfer functions involved in the MIMO feedback loop. Examples ======== >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback >>> tf1 = TransferFunction(p, 1 - p, p) >>> tf2 = TransferFunction(1, p, p) >>> tf3 = TransferFunction(1, 1, p) >>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]]) >>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]]) >>> F_1 = MIMOFeedback(sys1, sys2, 1) # Positive feedback >>> F_1.var p rrr=r=rCrB zMIMOFeedback.varcCr)z Returns the type of feedback interconnection of two models. ``1`` for Positive and ``-1`` for Negative. rrrr=r=rCr rzMIMOFeedback.signcCs6|jj}|jj}t|jj|j||S)a Returns the sensitivity function matrix of the feedback loop. Sensitivity of a closed-loop system is the ratio of change in the open loop gain to the change in the closed loop gain. .. note:: This method would not return the complementary sensitivity function. Examples ======== >>> from sympy import pprint >>> from sympy.abc import p >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback >>> tf1 = TransferFunction(p, 1 - p, p) >>> tf2 = TransferFunction(1, p, p) >>> tf3 = TransferFunction(1, 1, p) >>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]]) >>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]]) >>> F_1 = MIMOFeedback(sys1, sys2, 1) # Positive feedback >>> F_2 = MIMOFeedback(sys1, sys2) # Negative feedback >>> pprint(F_1.sensitivity, use_unicode=False) [ 4 3 2 5 4 2 ] [- p + 3*p - 4*p + 3*p - 1 p - 2*p + 3*p - 3*p + 1 ] [---------------------------- -----------------------------] [ 4 3 2 5 4 3 2 ] [ p + 3*p - 8*p + 8*p - 3 p + 3*p - 8*p + 8*p - 3*p] [ ] [ 4 3 2 3 2 ] [ p - p - p + p 3*p - 6*p + 4*p - 1 ] [ -------------------------- -------------------------- ] [ 4 3 2 4 3 2 ] [ p + 3*p - 8*p + 8*p - 3 p + 3*p - 8*p + 8*p - 3 ] >>> pprint(F_2.sensitivity, use_unicode=False) [ 4 3 2 5 4 2 ] [p - 3*p + 2*p + p - 1 p - 2*p + 3*p - 3*p + 1] [------------------------ --------------------------] [ 4 3 5 4 2 ] [ p - 3*p + 2*p - 1 p - 3*p + 2*p - p ] [ ] [ 4 3 2 4 3 ] [ p - p - p + p 2*p - 3*p + 2*p - 1 ] [ ------------------- --------------------- ] [ 4 3 4 3 ] [ p - 3*p + 2*p - 1 p - 3*p + 2*p - 1 ] )rrDr{rrrrrinv)r _sys1_mat _sys2_matr=r=rCr s 3   zMIMOFeedback.sensitivityTFcKs:|j|jj}t||j}|r|}|r|}|S)a Returns the resultant transfer function matrix obtained by the feedback interconnection. Examples ======== >>> from sympy import pprint >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback >>> tf1 = TransferFunction(s, 1 - s, s) >>> tf2 = TransferFunction(1, s, s) >>> tf3 = TransferFunction(5, 1, s) >>> tf4 = TransferFunction(s - 1, s, s) >>> tf5 = TransferFunction(0, 1, s) >>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]]) >>> sys2 = TransferFunctionMatrix([[tf3, tf5], [tf5, tf5]]) >>> F_1 = MIMOFeedback(sys1, sys2, 1) >>> pprint(F_1, use_unicode=False) / [ s 1 ] [5 0] \-1 [ s 1 ] | [----- - ] [- -] | [----- - ] | [1 - s s ] [1 1] | [1 - s s ] |I - [ ] *[ ] | * [ ] | [ 5 s - 1] [0 0] | [ 5 s - 1] | [ - -----] [- -] | [ - -----] \ [ 1 s ]{t} [1 1]{t}/ [ 1 s ]{t} >>> pprint(F_1.doit(), use_unicode=False) [ -s s - 1 ] [------- ----------- ] [6*s - 1 s*(6*s - 1) ] [ ] [5*s - 5 (s - 1)*(6*s + 24)] [------- ------------------] [6*s - 1 s*(6*s - 1) ]{t} If the user wants the resultant ``TransferFunctionMatrix`` object without canceling the common factors then the ``cancel`` kwarg should be passed ``False``. >>> pprint(F_1.doit(cancel=False), use_unicode=False) [ s*(s - 1) s - 1 ] [ ----------------- ----------- ] [ (1 - s)*(6*s - 1) s*(6*s - 1) ] [ ] [s*(25*s - 25) + 5*(1 - s)*(6*s - 1) s*(s - 1)*(6*s - 1) + s*(25*s - 25)] [----------------------------------- -----------------------------------] [ (1 - s)*(6*s - 1) 2 ] [ s *(6*s - 1) ]{t} If the user wants the expanded form of the resultant transfer function matrix, the ``expand`` kwarg should be passed as ``True``. >>> pprint(F_1.doit(expand=True), use_unicode=False) [ -s s - 1 ] [------- -------- ] [6*s - 1 2 ] [ 6*s - s ] [ ] [ 2 ] [5*s - 5 6*s + 18*s - 24] [------- ----------------] [6*s - 1 2 ] [ 6*s - s ]{t} )rrrDr{_to_TFMrBrr)rr(rrMr_resultant_tfmr=r=rCrD sA zMIMOFeedback.doitcKrRrrS)rrrrrr=r=rCr@ r!z4MIMOFeedback._eval_rewrite_as_TransferFunctionMatrixcCrr)r3rrrrr=r=rCr0C rzMIMOFeedback.__neg__)rV)TF)rrrrrrrrrBrrrDrr0rr=r=rrCr3 s T "     8Mr3cs*fddfdd|D}t|S)zOPrivate method to convert ImmutableMatrix to TransferFunctionMatrix efficientlyc t|Srr-rrrr=rCI  z_to_TFM..cg|] }fdd|DqS)cg|]}|qSr=r=r>rto_tfr=rCrDJ r\z&_to_TFM...r=r>rowrr=rCrDJ z_to_TFM..)tolistr4)rrBrsr=)rrBrCrG s rcseZdZdZfddZeddZeddZedd Z ed d Z ed d Z ddZ e ddZe ddZe ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'ZZS)(r4aF A class for representing the MIMO (multiple-input and multiple-output) generalization of the SISO (single-input and single-output) transfer function. It is a matrix of transfer functions (``TransferFunction``, SISO-``Series`` or SISO-``Parallel``). There is only one argument, ``arg`` which is also the compulsory argument. ``arg`` is expected to be strictly of the type list of lists which holds the transfer functions or reducible to transfer functions. Parameters ========== arg : Nested ``List`` (strictly). Users are expected to input a nested list of ``TransferFunction``, ``Series`` and/or ``Parallel`` objects. Examples ======== .. note:: ``pprint()`` can be used for better visualization of ``TransferFunctionMatrix`` objects. >>> from sympy.abc import s, p, a >>> from sympy import pprint >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel >>> tf_1 = TransferFunction(s + a, s**2 + s + 1, s) >>> tf_2 = TransferFunction(p**4 - 3*p + 2, s + p, s) >>> tf_3 = TransferFunction(3, s + 2, s) >>> tf_4 = TransferFunction(-a + p, 9*s - 9, s) >>> tfm_1 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_3]]) >>> tfm_1 TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),))) >>> tfm_1.var s >>> tfm_1.num_inputs 1 >>> tfm_1.num_outputs 3 >>> tfm_1.shape (3, 1) >>> tfm_1.args (((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)),) >>> tfm_2 = TransferFunctionMatrix([[tf_1, -tf_3], [tf_2, -tf_1], [tf_3, -tf_2]]) >>> tfm_2 TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)))) >>> pprint(tfm_2, use_unicode=False) # pretty-printing for better visualization [ a + s -3 ] [ ---------- ----- ] [ 2 s + 2 ] [ s + s + 1 ] [ ] [ 4 ] [p - 3*p + 2 -a - s ] [------------ ---------- ] [ p + s 2 ] [ s + s + 1 ] [ ] [ 4 ] [ 3 - p + 3*p - 2] [ ----- --------------] [ s + 2 p + s ]{t} TransferFunctionMatrix can be transposed, if user wants to switch the input and output transfer functions >>> tfm_2.transpose() TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(3, s + 2, s)), (TransferFunction(-3, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)))) >>> pprint(_, use_unicode=False) [ 4 ] [ a + s p - 3*p + 2 3 ] [---------- ------------ ----- ] [ 2 p + s s + 2 ] [s + s + 1 ] [ ] [ 4 ] [ -3 -a - s - p + 3*p - 2] [ ----- ---------- --------------] [ s + 2 2 p + s ] [ s + s + 1 ]{t} >>> tf_5 = TransferFunction(5, s, s) >>> tf_6 = TransferFunction(5*s, (2 + s**2), s) >>> tf_7 = TransferFunction(5, (s*(2 + s**2)), s) >>> tf_8 = TransferFunction(5, 1, s) >>> tfm_3 = TransferFunctionMatrix([[tf_5, tf_6], [tf_7, tf_8]]) >>> tfm_3 TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s)))) >>> pprint(tfm_3, use_unicode=False) [ 5 5*s ] [ - ------] [ s 2 ] [ s + 2] [ ] [ 5 5 ] [---------- - ] [ / 2 \ 1 ] [s*\s + 2/ ]{t} >>> tfm_3.var s >>> tfm_3.shape (2, 2) >>> tfm_3.num_outputs 2 >>> tfm_3.num_inputs 2 >>> tfm_3.args (((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))),) To access the ``TransferFunction`` at any index in the ``TransferFunctionMatrix``, use the index notation. >>> tfm_3[1, 0] # gives the TransferFunction present at 2nd Row and 1st Col. Similar to that in Matrix classes TransferFunction(5, s*(s**2 + 2), s) >>> tfm_3[0, 0] # gives the TransferFunction present at 1st Row and 1st Col. TransferFunction(5, s, s) >>> tfm_3[:, 0] # gives the first column TransferFunctionMatrix(((TransferFunction(5, s, s),), (TransferFunction(5, s*(s**2 + 2), s),))) >>> pprint(_, use_unicode=False) [ 5 ] [ - ] [ s ] [ ] [ 5 ] [----------] [ / 2 \] [s*\s + 2/]{t} >>> tfm_3[0, :] # gives the first row TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)),)) >>> pprint(_, use_unicode=False) [5 5*s ] [- ------] [s 2 ] [ s + 2]{t} To negate a transfer function matrix, ``-`` operator can be prepended: >>> tfm_4 = TransferFunctionMatrix([[tf_2], [-tf_1], [tf_3]]) >>> -tfm_4 TransferFunctionMatrix(((TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(-3, s + 2, s),))) >>> tfm_5 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, -tf_1]]) >>> -tfm_5 TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)), (TransferFunction(-3, s + 2, s), TransferFunction(a + s, s**2 + s + 1, s)))) ``subs()`` returns the ``TransferFunctionMatrix`` object with the value substituted in the expression. This will not mutate your original ``TransferFunctionMatrix``. >>> tfm_2.subs(p, 2) # substituting p everywhere in tfm_2 with 2. TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s)))) >>> pprint(_, use_unicode=False) [ a + s -3 ] [---------- ----- ] [ 2 s + 2 ] [s + s + 1 ] [ ] [ 12 -a - s ] [ ----- ----------] [ s + 2 2 ] [ s + s + 1] [ ] [ 3 -12 ] [ ----- ----- ] [ s + 2 s + 2 ]{t} >>> pprint(tfm_2, use_unicode=False) # State of tfm_2 is unchanged after substitution [ a + s -3 ] [ ---------- ----- ] [ 2 s + 2 ] [ s + s + 1 ] [ ] [ 4 ] [p - 3*p + 2 -a - s ] [------------ ---------- ] [ p + s 2 ] [ s + s + 1 ] [ ] [ 4 ] [ 3 - p + 3*p - 2] [ ----- --------------] [ s + 2 p + s ]{t} ``subs()`` also supports multiple substitutions. >>> tfm_2.subs({p: 2, a: 1}) # substituting p with 2 and a with 1 TransferFunctionMatrix(((TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-s - 1, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s)))) >>> pprint(_, use_unicode=False) [ s + 1 -3 ] [---------- ----- ] [ 2 s + 2 ] [s + s + 1 ] [ ] [ 12 -s - 1 ] [ ----- ----------] [ s + 2 2 ] [ s + s + 1] [ ] [ 3 -12 ] [ ----- ----- ] [ s + 2 s + 2 ]{t} Users can reduce the ``Series`` and ``Parallel`` elements of the matrix to ``TransferFunction`` by using ``doit()``. >>> tfm_6 = TransferFunctionMatrix([[Series(tf_3, tf_4), Parallel(tf_3, tf_4)]]) >>> tfm_6 TransferFunctionMatrix(((Series(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s)), Parallel(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s))),)) >>> pprint(tfm_6, use_unicode=False) [-a + p 3 -a + p 3 ] [-------*----- ------- + -----] [9*s - 9 s + 2 9*s - 9 s + 2]{t} >>> tfm_6.doit() TransferFunctionMatrix(((TransferFunction(-3*a + 3*p, (s + 2)*(9*s - 9), s), TransferFunction(27*s + (-a + p)*(s + 2) - 27, (s + 2)*(9*s - 9), s)),)) >>> pprint(_, use_unicode=False) [ -3*a + 3*p 27*s + (-a + p)*(s + 2) - 27] [----------------- ----------------------------] [(s + 2)*(9*s - 9) (s + 2)*(9*s - 9) ]{t} >>> tf_9 = TransferFunction(1, s, s) >>> tf_10 = TransferFunction(1, s**2, s) >>> tfm_7 = TransferFunctionMatrix([[Series(tf_9, tf_10), tf_9], [tf_10, Parallel(tf_9, tf_10)]]) >>> tfm_7 TransferFunctionMatrix(((Series(TransferFunction(1, s, s), TransferFunction(1, s**2, s)), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), Parallel(TransferFunction(1, s, s), TransferFunction(1, s**2, s))))) >>> pprint(tfm_7, use_unicode=False) [ 1 1 ] [---- - ] [ 2 s ] [s*s ] [ ] [ 1 1 1] [ -- -- + -] [ 2 2 s] [ s s ]{t} >>> tfm_7.doit() TransferFunctionMatrix(((TransferFunction(1, s**3, s), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), TransferFunction(s**2 + s, s**3, s)))) >>> pprint(_, use_unicode=False) [1 1 ] [-- - ] [ 3 s ] [s ] [ ] [ 2 ] [1 s + s] [-- ------] [ 2 3 ] [s s ]{t} Addition, subtraction, and multiplication of transfer function matrices can form unevaluated ``Series`` or ``Parallel`` objects. - For addition and subtraction: All the transfer function matrices must have the same shape. - For multiplication (C = A * B): The number of inputs of the first transfer function matrix (A) must be equal to the number of outputs of the second transfer function matrix (B). Also, use pretty-printing (``pprint``) to analyse better. >>> tfm_8 = TransferFunctionMatrix([[tf_3], [tf_2], [-tf_1]]) >>> tfm_9 = TransferFunctionMatrix([[-tf_3]]) >>> tfm_10 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_4]]) >>> tfm_11 = TransferFunctionMatrix([[tf_4], [-tf_1]]) >>> tfm_12 = TransferFunctionMatrix([[tf_4, -tf_1, tf_3], [-tf_2, -tf_4, -tf_3]]) >>> tfm_8 + tfm_10 MIMOParallel(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),)))) >>> pprint(_, use_unicode=False) [ 3 ] [ a + s ] [ ----- ] [ ---------- ] [ s + 2 ] [ 2 ] [ ] [ s + s + 1 ] [ 4 ] [ ] [p - 3*p + 2] [ 4 ] [------------] + [p - 3*p + 2] [ p + s ] [------------] [ ] [ p + s ] [ -a - s ] [ ] [ ---------- ] [ -a + p ] [ 2 ] [ ------- ] [ s + s + 1 ]{t} [ 9*s - 9 ]{t} >>> -tfm_10 - tfm_8 MIMOParallel(TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a - p, 9*s - 9, s),))), TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),)))) >>> pprint(_, use_unicode=False) [ -a - s ] [ -3 ] [ ---------- ] [ ----- ] [ 2 ] [ s + 2 ] [ s + s + 1 ] [ ] [ ] [ 4 ] [ 4 ] [- p + 3*p - 2] [- p + 3*p - 2] + [--------------] [--------------] [ p + s ] [ p + s ] [ ] [ ] [ a + s ] [ a - p ] [ ---------- ] [ ------- ] [ 2 ] [ 9*s - 9 ]{t} [ s + s + 1 ]{t} >>> tfm_12 * tfm_8 MIMOSeries(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s))))) >>> pprint(_, use_unicode=False) [ 3 ] [ ----- ] [ -a + p -a - s 3 ] [ s + 2 ] [ ------- ---------- -----] [ ] [ 9*s - 9 2 s + 2] [ 4 ] [ s + s + 1 ] [p - 3*p + 2] [ ] *[------------] [ 4 ] [ p + s ] [- p + 3*p - 2 a - p -3 ] [ ] [-------------- ------- -----] [ -a - s ] [ p + s 9*s - 9 s + 2]{t} [ ---------- ] [ 2 ] [ s + s + 1 ]{t} >>> tfm_12 * tfm_8 * tfm_9 MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s))))) >>> pprint(_, use_unicode=False) [ 3 ] [ ----- ] [ -a + p -a - s 3 ] [ s + 2 ] [ ------- ---------- -----] [ ] [ 9*s - 9 2 s + 2] [ 4 ] [ s + s + 1 ] [p - 3*p + 2] [ -3 ] [ ] *[------------] *[-----] [ 4 ] [ p + s ] [s + 2]{t} [- p + 3*p - 2 a - p -3 ] [ ] [-------------- ------- -----] [ -a - s ] [ p + s 9*s - 9 s + 2]{t} [ ---------- ] [ 2 ] [ s + s + 1 ]{t} >>> tfm_10 + tfm_8*tfm_9 MIMOParallel(TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),))), MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))))) >>> pprint(_, use_unicode=False) [ a + s ] [ 3 ] [ ---------- ] [ ----- ] [ 2 ] [ s + 2 ] [ s + s + 1 ] [ ] [ ] [ 4 ] [ 4 ] [p - 3*p + 2] [ -3 ] [p - 3*p + 2] + [------------] *[-----] [------------] [ p + s ] [s + 2]{t} [ p + s ] [ ] [ ] [ -a - s ] [ -a + p ] [ ---------- ] [ ------- ] [ 2 ] [ 9*s - 9 ]{t} [ s + s + 1 ]{t} These unevaluated ``Series`` or ``Parallel`` objects can convert into the resultant transfer function matrix using ``.doit()`` method or by ``.rewrite(TransferFunctionMatrix)``. >>> (-tfm_8 + tfm_10 + tfm_8*tfm_9).doit() TransferFunctionMatrix(((TransferFunction((a + s)*(s + 2)**3 - 3*(s + 2)**2*(s**2 + s + 1) - 9*(s + 2)*(s**2 + s + 1), (s + 2)**3*(s**2 + s + 1), s),), (TransferFunction((p + s)*(-3*p**4 + 9*p - 6), (p + s)**2*(s + 2), s),), (TransferFunction((-a + p)*(s + 2)*(s**2 + s + 1)**2 + (a + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + (3*a + 3*s)*(9*s - 9)*(s**2 + s + 1), (s + 2)*(9*s - 9)*(s**2 + s + 1)**2, s),))) >>> (-tfm_12 * -tfm_8 * -tfm_9).rewrite(TransferFunctionMatrix) TransferFunctionMatrix(((TransferFunction(3*(-3*a + 3*p)*(p + s)*(s + 2)*(s**2 + s + 1)**2 + 3*(-3*a - 3*s)*(p + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + 3*(a + s)*(s + 2)**2*(9*s - 9)*(-p**4 + 3*p - 2)*(s**2 + s + 1), (p + s)*(s + 2)**3*(9*s - 9)*(s**2 + s + 1)**2, s),), (TransferFunction(3*(-a + p)*(p + s)*(s + 2)**2*(-p**4 + 3*p - 2)*(s**2 + s + 1) + 3*(3*a + 3*s)*(p + s)**2*(s + 2)*(9*s - 9) + 3*(p + s)*(s + 2)*(9*s - 9)*(-3*p**4 + 9*p - 6)*(s**2 + s + 1), (p + s)**2*(s + 2)**3*(9*s - 9)*(s**2 + s + 1), s),))) See Also ======== TransferFunction, MIMOSeries, MIMOParallel, Feedback csg}z |ddj}Wn tyttdw|D]+}g}|D]}t|ts.ttd||jkr9ttd||q!||qt|tt t fr[t dd|Dddi}t t | ||}t||_|S) Nrz `arg` param in TransferFunctionMatrix should strictly be a nested list containing TransferFunction objects.zr Each element is expected to be of type `SISOLinearTimeInvariant`.z Conflicting value(s) found for `var`. All TransferFunction instances in TransferFunctionMatrix should use the same complex variable in Laplace domain.css|] }t|ddiVqdS)rFNr )r>rGr=r=rCr rz1TransferFunctionMatrix.__new__..rF)rBrrr+rrrrr9rr rr4rrr{)rrs expr_mat_argrBrtempelementrFrr=rCr s(        zTransferFunctionMatrix.__new__cCs t||S)a Creates a new ``TransferFunctionMatrix`` efficiently from a SymPy Matrix of ``Expr`` objects. Parameters ========== matrix : ``ImmutableMatrix`` having ``Expr``/``Number`` elements. var : Symbol Complex variable of the Laplace transform which will be used by the all the ``TransferFunction`` objects in the ``TransferFunctionMatrix``. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunctionMatrix >>> from sympy import Matrix, pprint >>> M = Matrix([[s, 1/s], [1/(s+1), s]]) >>> M_tf = TransferFunctionMatrix.from_Matrix(M, s) >>> pprint(M_tf, use_unicode=False) [ s 1] [ - -] [ 1 s] [ ] [ 1 s] [----- -] [s + 1 1]{t} >>> M_tf.elem_poles() [[[], [0]], [[-1], []]] >>> M_tf.elem_zeros() [[[0], []], [[], [0]]] )r)rmatrixrBr=r=rCr| s #z"TransferFunctionMatrix.from_MatrixcCs|jdddjS)a Returns the complex variable used by all the transfer functions or ``Series``/``Parallel`` objects in a transfer function matrix. Examples ======== >>> from sympy.abc import p, s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p) >>> G2 = TransferFunction(p, 4 - p, p) >>> G3 = TransferFunction(0, p**4 - 1, p) >>> G4 = TransferFunction(s + 1, s**2 + s + 1, s) >>> S1 = Series(G1, G2) >>> S2 = Series(-G3, Parallel(G2, -G1)) >>> tfm1 = TransferFunctionMatrix([[G1], [G2], [G3]]) >>> tfm1.var p >>> tfm2 = TransferFunctionMatrix([[-S1, -S2], [S1, S2]]) >>> tfm2.var p >>> tfm3 = TransferFunctionMatrix([[G4]]) >>> tfm3.var s rrIrr=r=rCrB szTransferFunctionMatrix.varcC |jjdS)a- Returns the number of inputs of the system. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix >>> G1 = TransferFunction(s + 3, s**2 - 3, s) >>> G2 = TransferFunction(4, s**2, s) >>> G3 = TransferFunction(p**2 + s**2, p - 3, s) >>> tfm_1 = TransferFunctionMatrix([[G2, -G1, G3], [-G2, -G1, -G3]]) >>> tfm_1.num_inputs 3 See Also ======== num_outputs rJr{ryrr=r=rCrr  z!TransferFunctionMatrix.num_inputscCr)a* Returns the number of outputs of the system. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunctionMatrix >>> from sympy import Matrix >>> M_1 = Matrix([[s], [1/s]]) >>> TFM = TransferFunctionMatrix.from_Matrix(M_1, s) >>> print(TFM) TransferFunctionMatrix(((TransferFunction(s, 1, s),), (TransferFunction(1, s, s),))) >>> TFM.num_outputs 2 See Also ======== num_inputs rrrr=r=rCrq0 s z"TransferFunctionMatrix.num_outputscCr)a Returns the shape of the transfer function matrix, that is, ``(# of outputs, # of inputs)``. Examples ======== >>> from sympy.abc import s, p >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix >>> tf1 = TransferFunction(p**2 - 1, s**4 + s**3 - p, p) >>> tf2 = TransferFunction(1 - p, p**2 - 3*p + 7, p) >>> tf3 = TransferFunction(3, 4, p) >>> tfm1 = TransferFunctionMatrix([[tf1, -tf2]]) >>> tfm1.shape (1, 2) >>> tfm2 = TransferFunctionMatrix([[-tf2, tf3], [tf1, -tf1]]) >>> tfm2.shape (2, 2) rrr=r=rCryJ rzTransferFunctionMatrix.shapecCs|j }t||jSr)r{rrB)rnegr=r=rCr0a s zTransferFunctionMatrix.__neg__cCs.t|ts t||St|j}t|g|RSrrr)r=r=rCre s   zTransferFunctionMatrix.__add__cCrXrr=rr=r=rCr#m rYzTransferFunctionMatrix.__sub__cCs0t|ts t||St|j}tg||RSrrr)r=r=rCr'q s   zTransferFunctionMatrix.__mul__cCs0|j|}t|trt||jSt||jSr)r{ __getitem__rrrrBr-r)rkeytruncr=r=rCry s   z"TransferFunctionMatrix.__getitem__cCs|j}t||jS)z[Returns the transpose of the ``TransferFunctionMatrix`` (switched input and output layers).)r{ transposerrB)rtransposed_matr=r=rCr s  z TransferFunctionMatrix.transposecCdd|jdDS)a Returns the poles of each element of the ``TransferFunctionMatrix``. .. note:: Actual poles of a MIMO system are NOT the poles of individual elements. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix >>> tf_1 = TransferFunction(3, (s + 1), s) >>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s) >>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s) >>> tf_4 = TransferFunction(s + 2, s**2 + 5*s - 10, s) >>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]]) >>> tfm_1 TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s + 2, s**2 + 5*s - 10, s)))) >>> tfm_1.elem_poles() [[[-1], [-2, -1]], [[-2, -1], [-5/2 + sqrt(65)/2, -sqrt(65)/2 - 5/2]]] See Also ======== elem_zeros cSg|] }dd|DqS)cSg|]}|qSr=)rr>rr=r=rCrD r\z@TransferFunctionMatrix.elem_poles...r=rr=r=rCrD z5TransferFunctionMatrix.elem_poles..rrDrrr=r=rC elem_poles z!TransferFunctionMatrix.elem_polescCr)a Returns the zeros of each element of the ``TransferFunctionMatrix``. .. note:: Actual zeros of a MIMO system are NOT the zeros of individual elements. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix >>> tf_1 = TransferFunction(3, (s + 1), s) >>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s) >>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s) >>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s) >>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]]) >>> tfm_1 TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)))) >>> tfm_1.elem_zeros() [[[], [-6]], [[-3], [4, 5]]] See Also ======== elem_poles cSr)cSrr=)r rr=r=rCrD r\z@TransferFunctionMatrix.elem_zeros...r=rr=r=rCrD rz5TransferFunctionMatrix.elem_zeros..rrrr=r=rC elem_zeros rz!TransferFunctionMatrix.elem_zeroscCs|j|j|}|S)ao Evaluates system response of each transfer function in the ``TransferFunctionMatrix`` at any point in the real or complex plane. Examples ======== >>> from sympy.abc import s >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix >>> from sympy import I >>> tf_1 = TransferFunction(3, (s + 1), s) >>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s) >>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s) >>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s) >>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]]) >>> tfm_1 TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)))) >>> tfm_1.eval_frequency(2) Matrix([ [ 1, 2/3], [5/12, 3/2]]) >>> tfm_1.eval_frequency(I*2) Matrix([ [ 3/5 - 6*I/5, -I], [3/20 - 11*I/20, -101/74 + 23*I/74]]) )r{rrBr)rrrr=r=rCr sz%TransferFunctionMatrix.eval_frequencycCsdd|jdDS)z8Returns flattened list of args in TransferFunctionMatrixcSsg|] }|D]}|qqSr=r=)r>tupelemr=r=rCrD rz0TransferFunctionMatrix._flat..rrrr=r=rC_flat szTransferFunctionMatrix._flatcs(t||jfdd}t||jS)zGCalls evalf() on each transfer function in the transfer function matrixcs |jdS)NrH)evalfrdpsr=rCr rz4TransferFunctionMatrix._eval_evalf..)r,r{ applyfuncrrB)rrrr=rrCr s z"TransferFunctionMatrix._eval_evalfcKs|jdd}t||jS)z'Simplifies the transfer function matrixcSs t|ddS)NFr )r(rr=r=rCr rz7TransferFunctionMatrix._eval_simplify..)r{rrrB)rrsimp_matr=r=rCr s z%TransferFunctionMatrix._eval_simplifycKs|jjdi|}t||jS)z$Expands the transfer function matrixNr=)r{rrrB)rrM expand_matr=r=rCr s zTransferFunctionMatrix.expand)rrrrrrr|rrBrrrqryr0rrr#r'rrrrrrrrrrr=r=rrCr4N s> d# $       r4cseZdZdZd5fdd ZeddZeddZed d Zed d Z ed dZ eddZ eddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4ZZS)6r5aj State space model (ssm) of a linear, time invariant control system. Represents the standard state-space model with A, B, C, D as state-space matrices. This makes the linear control system: (1) x'(t) = A * x(t) + B * u(t); x in R^n , u in R^k (2) y(t) = C * x(t) + D * u(t); y in R^m where u(t) is any input signal, y(t) the corresponding output, and x(t) the system's state. Parameters ========== A : Matrix The State matrix of the state space model. B : Matrix The Input-to-State matrix of the state space model. C : Matrix The State-to-Output matrix of the state space model. D : Matrix The Feedthrough matrix of the state space model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace The easiest way to create a StateSpaceModel is via four matrices: >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> StateSpace(A, B, C, D) StateSpace(Matrix([ [1, 2], [1, 0]]), Matrix([ [1], [1]]), Matrix([[0, 1]]), Matrix([[0]])) One can use less matrices. The rest will be filled with a minimum of zeros: >>> StateSpace(A, B) StateSpace(Matrix([ [1, 2], [1, 0]]), Matrix([ [1], [1]]), Matrix([[0, 0]]), Matrix([[0]])) See Also ======== TransferFunction, TransferFunctionMatrix References ========== .. [1] https://en.wikipedia.org/wiki/State-space_representation .. [2] https://in.mathworks.com/help/control/ref/ss.html Ncsn|durtd}|durt|jd}|durtd|j}|dur't|j|j}t|}t|}t|}t|}t|trt|trt|trt|tr|j|jkrUtd|j|jkr_td|j|jkritd|j|jkrstd|j|jkr}tdtt| |||||}||_ ||_ ||_ ||_ |j}|j}|dkr|dkrd|_t|_|Sd|_t|_|Std ) NrJz!Matrix A must be a square matrix.z3Matrices A and B must have the same number of rows.z3Matrices C and D must have the same number of rows.z6Matrices A and C must have the same number of columns.z6Matrices B and D must have the same number of columns.TFz0A, B, C and D inputs must all be sympy Matrices.)r rowscolsrrrrrr5r_A_B_C_Drrrrr)rrrr r rFrqrrrr=rCr0sT       zStateSpace.__new__cCr)a Returns the state matrix of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.state_matrix Matrix([ [1, 2], [1, 0]]) )rrr=r=rC state_matrixjzStateSpace.state_matrixcCr)a Returns the input matrix of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.input_matrix Matrix([ [1], [1]]) )rrr=r=rC input_matrixrzStateSpace.input_matrixcCr)a Returns the output matrix of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.output_matrix Matrix([[0, 1]]) )rrr=r=rC output_matrixzStateSpace.output_matrixcCr)a Returns the feedforward matrix of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.feedforward_matrix Matrix([[0]]) )rrr=r=rCfeedforward_matrixrzStateSpace.feedforward_matrixcCr)a Returns the number of states of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.num_states 2 )rrrr=r=rC num_stateszStateSpace.num_statescCr)a Returns the number of inputs of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.num_inputs 1 )rrrr=r=rCrrrzStateSpace.num_inputscCr)a Returns the number of outputs of the model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[1, 2], [1, 0]]) >>> B = Matrix([1, 1]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.num_outputs 1 )rrrr=r=rCrqrzStateSpace.num_outputscCs>t|}t|jj|d|jj|d|jj|d|jj|dS)zr Returns state space model where numerical expressions are evaluated into floating point numbers. r)r,r5rrrrr)rrrr=r=rCrs    zStateSpace._eval_evalfcsltd|jjd}t|}|j||j|j|j}|}fddfdd| D}|S)a Returns the equivalent Transfer Function of the state space model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import TransferFunction, StateSpace >>> A = Matrix([[-5, -1], [3, -1]]) >>> B = Matrix([2, 5]) >>> C = Matrix([[1, 2]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss.rewrite(TransferFunction) [[TransferFunction(12*s + 59, s**2 + 6*s + 8, s)]] rhrcrrrr)rhr=rCr#rz>StateSpace._eval_rewrite_as_TransferFunction..cr)crr=r=rrr=rCrD$r\zKStateSpace._eval_rewrite_as_TransferFunction...r=)r>sublistrr=rCrD$rz@StateSpace._eval_rewrite_as_TransferFunction..) rrryrrsolverrrr)rrrHrGtf_matr=)rhrrCrU s " z,StateSpace._eval_rewrite_as_TransferFunctioncstttttfr|j}|j}|j}|j fdd}nTtt s&t d|j j ks2|j j kr6td|jt|jjdjjd}tjjd|jjdj}||}|jj}|jj}|jj}t ||||S)a Add two State Space systems (parallel connection). Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A1 = Matrix([[1]]) >>> B1 = Matrix([[2]]) >>> C1 = Matrix([[-1]]) >>> D1 = Matrix([[-2]]) >>> A2 = Matrix([[-1]]) >>> B2 = Matrix([[-2]]) >>> C2 = Matrix([[1]]) >>> D2 = Matrix([[2]]) >>> ss1 = StateSpace(A1, B1, C1, D1) >>> ss2 = StateSpace(A2, B2, C2, D2) >>> ss1 + ss2 StateSpace(Matrix([ [1, 0], [0, -1]]), Matrix([ [ 2], [-2]]), Matrix([[-1, 1]]), Matrix([[0]])) cs|Srr=rrr=rCrGz$StateSpace.__add__..z4Addition is only supported for 2 State Space models.z=Systems with incompatible inputs and outputs cannot be added.rrV)rintfloatcomplexrrrrrrr5rrrrqrrr ryrrrrrr r m1m2r=rrCr's  ""  zStateSpace.__add__cCr)a Right add two State Space systems. Examples ======== >>> from sympy.physics.control import StateSpace >>> s = StateSpace() >>> 5 + s StateSpace(Matrix([[0]]), Matrix([[0]]), Matrix([[0]]), Matrix([[5]])) r=rr=r=rCr [s zStateSpace.__radd__cCrX)a Subtract two State Space systems. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A1 = Matrix([[1]]) >>> B1 = Matrix([[2]]) >>> C1 = Matrix([[-1]]) >>> D1 = Matrix([[-2]]) >>> A2 = Matrix([[-1]]) >>> B2 = Matrix([[-2]]) >>> C2 = Matrix([[1]]) >>> D2 = Matrix([[2]]) >>> ss1 = StateSpace(A1, B1, C1, D1) >>> ss2 = StateSpace(A2, B2, C2, D2) >>> ss1 - ss2 StateSpace(Matrix([ [1, 0], [0, -1]]), Matrix([ [ 2], [-2]]), Matrix([[-1, -1]]), Matrix([[-4]])) r=rr=r=rCr#js zStateSpace.__sub__cCs || S)a Right subtract two tate Space systems. Examples ======== >>> from sympy.physics.control import StateSpace >>> s = StateSpace() >>> 5 - s StateSpace(Matrix([[0]]), Matrix([[0]]), Matrix([[0]]), Matrix([[5]])) r=rr=r=rCr%s zStateSpace.__rsub__cCst|j|j|j |j S)a  Returns the negation of the state space model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-5, -1], [3, -1]]) >>> B = Matrix([2, 5]) >>> C = Matrix([[1, 2]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> -ss StateSpace(Matrix([ [-5, -1], [ 3, -1]]), Matrix([ [2], [5]]), Matrix([[-1, -2]]), Matrix([[0]])) )r5rrrrrr=r=rCr0szStateSpace.__neg__cstttttfr$|j}|j}|jfdd}|j fdd}nMtt s-t d|j j kr7tdjtjjd|jjd}|jj|j}||}j|jj }|j j|j}|j j }t ||||S)a Multiplication of two State Space systems (serial connection). Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-5, -1], [3, -1]]) >>> B = Matrix([2, 5]) >>> C = Matrix([[1, 2]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> ss*5 StateSpace(Matrix([ [-5, -1], [ 3, -1]]), Matrix([ [2], [5]]), Matrix([[5, 10]]), Matrix([[0]])) c|Srr=rrr=rCrrz$StateSpace.__mul__..crrr=rrr=rCrrz:Multiplication is only supported for 2 State Space models.zBSystems with incompatible inputs and outputs cannot be multiplied.rrJ)rrrrrrrrrrr5rrrrqrrr ryrrr=rrCr's   "  zStateSpace.__mul__cs\tttttfr*|j}|j}|jfdd}|j fdd}t ||||S|S)a Right multiply two tate Space systems. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-5, -1], [3, -1]]) >>> B = Matrix([2, 5]) >>> C = Matrix([[1, 2]]) >>> D = Matrix([0]) >>> ss = StateSpace(A, B, C, D) >>> 5*ss StateSpace(Matrix([ [-5, -1], [ 3, -1]]), Matrix([ [10], [25]]), Matrix([[1, 2]]), Matrix([[0]])) crrr=rrr=rCrrz%StateSpace.__rmul__..crrr=rrr=rCrr) rrrrrrrrrrr5)rrrr rr r=rrCr6szStateSpace.__rmul__c CsF|j}|j}|j}|j}d|d|d|d|d S)Nz StateSpace( z, ))r__repr__rrr)rA_strB_strC_strD_strr=r=rCrs    zStateSpace.__repr__c Cs*|j|j}|j|j}|j|j}t||}t||}t||}t||}|j|d|jd|jf<|j||jd|jdf<|j|d|jd|jf<|j||jd|jdf<|j|d|jd|jf<|j||jd|jdf<|j|d|jd|jf<|j||jd|jdf<t||||S)a Returns the first model appended with the second model. The order is preserved. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A1 = Matrix([[1]]) >>> B1 = Matrix([[2]]) >>> C1 = Matrix([[-1]]) >>> D1 = Matrix([[-2]]) >>> A2 = Matrix([[-1]]) >>> B2 = Matrix([[-2]]) >>> C2 = Matrix([[1]]) >>> D2 = Matrix([[2]]) >>> ss1 = StateSpace(A1, B1, C1, D1) >>> ss2 = StateSpace(A2, B2, C2, D2) >>> ss1.append(ss2) StateSpace(Matrix([ [1, 0], [0, -1]]), Matrix([ [2, 0], [0, -2]]), Matrix([ [-1, 0], [ 0, 1]]), Matrix([ [-2, 0], [ 0, 2]])) N) rrrrqr rrrrr5) rrrHr r.rrr r r=r=rCrs       zStateSpace.appendcCs6|j}|j}td|D] }||j|j|}q |S)a Returns the observability matrix of the state space model: [C, C * A^1, C * A^2, .. , C * A^(n-1)]; A in R^(n x n), C in R^(m x k) Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> ob = ss.observability_matrix() >>> ob Matrix([ [0, 1], [1, 0]]) References ========== .. [1] https://in.mathworks.com/help/control/ref/statespacemodel.obsv.html rJ)rrrFrr)rrHobrOr=r=rCobservability_matrix7s zStateSpace.observability_matrixcCr)a Returns the observable subspace of the state space model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> ob_subspace = ss.observable_subspace() >>> ob_subspace [Matrix([ [0], [1]]), Matrix([ [1], [0]])] )r columnspacerr=r=rCobservable_subspaceXrzStateSpace.observable_subspacecC||jkS)a Returns if the state space model is observable. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> ss.is_observable() True )rrankrrr=r=rC is_observableqzStateSpace.is_observablecCs<|j}|jjd}td|D] }||j||j}q|S)a Returns the controllability matrix of the system: [B, A * B, A^2 * B, .. , A^(n-1) * B]; A in R^(n x n), B in R^(n x m) Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> ss.controllability_matrix() Matrix([ [0.5, -0.75], [ 0, 0.5]]) References ========== .. [1] https://in.mathworks.com/help/control/ref/statespacemodel.ctrb.html rrJ)rrryrFr)rcorHrOr=r=rCcontrollability_matrixs  z!StateSpace.controllability_matrixcCr)a/ Returns the controllable subspace of the state space model. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> co_subspace = ss.controllable_subspace() >>> co_subspace [Matrix([ [0.5], [ 0]]), Matrix([ [-0.75], [ 0.5]])] )rrrr=r=rCcontrollable_subspacerz StateSpace.controllable_subspacecCr)a Returns if the state space model is controllable. Examples ======== >>> from sympy import Matrix >>> from sympy.physics.control import StateSpace >>> A = Matrix([[-1.5, -2], [1, 0]]) >>> B = Matrix([0.5, 0]) >>> C = Matrix([[0, 1]]) >>> D = Matrix([1]) >>> ss = StateSpace(A, B, C, D) >>> ss.is_controllable() True )rrrrr=r=rCis_controllablerzStateSpace.is_controllable)NNNN)rrrrrrrrrrrrrrqrrUrr r#r%r0r'r6rrrrrrrrrr=r=rrCr5 sD>:        4/ 2! r5N)^typingrsympyrrrrsympy.core.addrsympy.core.basicrsympy.core.containersr sympy.core.evalfr sympy.core.exprr sympy.core.functionrsympy.core.logicrsympy.core.mulrsympy.core.numbersrrrsympy.core.powerrsympy.core.singletonrsympy.core.symbolrrrrsympy.core.sympifyrrsympy.matricesrrrrrr &sympy.functions.elementary.exponentialr!r"sympy.matrices.expressionsr#r$ sympy.polysr%r&sympy.polys.polyrootsr'sympy.polys.polytoolsr(r) sympy.seriesr*sympy.utilities.miscr+mpmath.libmp.libmpfr,__all__rIr6r7r8r9r:r;rrrrrrr-r<rBr.rsr/r0r1r2rr3rr4r5r=r=r=rCs                 LSI  s  Gi:? a(