(ph>SrSSKrSSKJrJrJrJrJrJrJ r J r J r SSK J r SSKJrJrJr /SQrSrS rS rS rS rS rSSjrSSjrSrSSjrSSjrg)zr ltisys -- a collection of functions to convert linear time invariant systems from one representation to another. N) r_eye atleast_2dpolydotasarrayzerosarrayouter)linalg)tf2zpkzpk2tf normalize)tf2ssabcd_normalizess2tfzpk2ssss2zpk cont2discretecB[X5up[UR5nUS:Xa[U/UR5nURSn[U5nX4:a Sn[ U5eUS:XdUS:Xa>[ /[5[ /[5[ /[5[ /[54$[R"[R"URSXC- 4URS9U45nURSS:a[USS2S45nO[ S//[5nUS:XaZURUR5n[S5[SURS45[URSS45U4$[ USS/5*n[U[US- US- 54n[US- S5n USS2SS24[USS2S4USS5- n URU RSU RS45nXX4$) a)Transfer function to state-space representation. Parameters ---------- num, den : array_like Sequences representing the coefficients of the numerator and denominator polynomials, in order of descending degree. The denominator needs to be at least as long as the numerator. Returns ------- A, B, C, D : ndarray State space representation of the system, in controller canonical form. Examples -------- Convert the transfer function: .. math:: H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1} >>> num = [1, 3, 3] >>> den = [1, 2, 1] to the state-space representation: .. math:: \dot{\textbf{x}}(t) = \begin{bmatrix} -2 & -1 \\ 1 & 0 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \\ 0 \end{bmatrix} \textbf{u}(t) \\ \textbf{y}(t) = \begin{bmatrix} 1 & 2 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \end{bmatrix} \textbf{u}(t) >>> from scipy.signal import tf2ss >>> A, B, C, D = tf2ss(num, den) >>> A array([[-2., -1.], [ 1., 0.]]) >>> B array([[ 1.], [ 0.]]) >>> C array([[ 1., 2.]]) >>> D array([[ 1.]]) r z7Improper transfer function. `num` is longer than `den`.r)dtypeN)r r )rlenshaperr ValueErrorr floatnphstackr rreshaperrr ) numdennnMKmsgDfrowABCs O/var/www/html/venv/lib/python3.13/site-packages/scipy/signal/_lti_conversion.pyrrsp"HC SYYB QwseSYY' ! A CAuGoAvab% %E"2E"e4Db% " " ))RXXsyy|QU3399EsK LC yy}q s1a4y ! A3% Av IIcii f ua_5qwwqz1o&+ + 3qr7)  D 4QUAE" "#A AE1 A AqrE U3q!t9c!"g..A 1771:qwwqz*+A :c"Uc [S5$U$)Nrr)r args r-_none_to_empty_2dr3ss {V} r.c Ub [U5$gN)rr1s r-_atleast_2d_or_noner6zs #r.c"Ub UR$g)N)NN)r)r%s r-_shape_or_noner8s}wwr.c$UH nUcMUs $ gr5)argsr2s r-_choice_not_noner<s ?Jr.crURS:Xa [U5$URU:wa [S5eU$)Nr0z*The input arrays have incompatible shapes.)rr r)r%rs r-_restorer>s5ww&U| 77e IJ Jr.c[[XX#45upp#[U5upE[U5upg[U5up[U5up[XFU 5n [X{5n [X5nU bU bUc [ S5e[[ XX#45upp#[ X U 45n[ XU 45n[ X.U 45n[ X>U 45nXX#4$)akCheck state-space matrices and ensure they are 2-D. If enough information on the system is provided, that is, enough properly-shaped arrays are passed to the function, the missing ones are built from this information, ensuring the correct number of rows and columns. Otherwise a ValueError is raised. Parameters ---------- A, B, C, D : array_like, optional State-space matrices. All of them are None (missing) by default. See `ss2tf` for format. Returns ------- A, B, C, D : array Properly shaped state-space matrices. Raises ------ ValueError If not enough information on the system was provided. z%Not enough information on the system.)mapr6r8r<rr3r>)r*r+r,r(MANAMBNBMCNCMDNDpqrs r-rrs2(1,7JA! A FB A FB A FB A FB$A A AyAI@AA&q 5JA!FAFAFAFA :r.c[XX#5upp#URupVXF:a [S5eUSS2XDS-24nUSS2XDS-24n[U5nURS:XaKURS:Xa;[ R "U5nURS:XaURS:Xa/nX4$URSn USS2S4USS2S4-USSS24-U-S-n [ R"XYS-4U R5n[U5H8n [X+SS245n [U[X5- 5X;S- U--X'M: X4$![a SnGN f=f)aState-space to transfer function. A, B, C, D defines a linear state-space system with `p` inputs, `q` outputs, and `n` state variables. Parameters ---------- A : array_like State (or system) matrix of shape ``(n, n)`` B : array_like Input matrix of shape ``(n, p)`` C : array_like Output matrix of shape ``(q, n)`` D : array_like Feedthrough (or feedforward) matrix of shape ``(q, p)`` input : int, optional For multiple-input systems, the index of the input to use. Returns ------- num : 2-D ndarray Numerator(s) of the resulting transfer function(s). `num` has one row for each of the system's outputs. Each row is a sequence representation of the numerator polynomial. den : 1-D ndarray Denominator of the resulting transfer function(s). `den` is a sequence representation of the denominator polynomial. Examples -------- Convert the state-space representation: .. math:: \dot{\textbf{x}}(t) = \begin{bmatrix} -2 & -1 \\ 1 & 0 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \\ 0 \end{bmatrix} \textbf{u}(t) \\ \textbf{y}(t) = \begin{bmatrix} 1 & 2 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \end{bmatrix} \textbf{u}(t) >>> A = [[-2, -1], [1, 0]] >>> B = [[1], [0]] # 2-D column vector >>> C = [[1, 2]] # 2-D row vector >>> D = 1 to the transfer function: .. math:: H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1} >>> from scipy.signal import ss2tf >>> ss2tf(A, B, C, D) (array([[1., 3., 3.]]), array([ 1., 2., 1.])) z)System does not have the input specified.Nr r) rrrrsizerravelemptyrrangerr) r*r+r,r(inputnoutninr#r" num_states type_testkCks r-rrsjt a+JA!ID |DEE !U19_ A !U19_ A1g ! !&&A+hhqk FFaKaffkCxJ!Q$!AqD'!AadG+a/#5I ((Dq.)9?? ;C 4[ Q$ a#a*n%S(88 8O! s E E E c&[[XU56$)a Zero-pole-gain representation to state-space representation Parameters ---------- z, p : sequence Zeros and poles. k : float System gain. Returns ------- A, B, C, D : ndarray State space representation of the system, in controller canonical form. )rr)zrIrWs r-rrs" &q/ ""r.c $[[XX#US96$)aVState-space representation to zero-pole-gain representation. A, B, C, D defines a linear state-space system with `p` inputs, `q` outputs, and `n` state variables. Parameters ---------- A : array_like State (or system) matrix of shape ``(n, n)`` B : array_like Input matrix of shape ``(n, p)`` C : array_like Output matrix of shape ``(q, n)`` D : array_like Feedthrough (or feedforward) matrix of shape ``(q, p)`` input : int, optional For multiple-input systems, the index of the input to use. Returns ------- z, p : sequence Zeros and poles. k : float System gain. )rR)rr)r*r+r,r(rRs r-rr1s6 5q51 22r.c$ [U5S:XaUR5$[U5S:Xa9[[USUS5XUS9n[ USUSUSUS5U4-$[U5S:Xa=[[ USUSUS5UX#S9n[ USUSUSUS5U4-$[U5S:XaUupVpxO [S5eUS:Xa%Uc [S 5eUS:dUS:a [S 5eUS:Xa[R"URS5X1-U-- n [R"U [R"URS5S U- U-U--5n [R"XU-5n [R"U R5UR55n U R5n X[R"X{5--n GOUS :XdUS:Xa [XSSS9$US:XdUS:Xa [XSSS9$US:Xa [XSS S9$US:XGa [R"XV45n[R"[R "URSURS45[R "URSURS4545n[R""X45n[R$"UU-5nUS URS2S S 24nUS S 2SURS24n US S 2URSS 24n Un Un GOMUS:XaURSnURSn[R&"[R("XV/5U-[R"U55n[!UUSU--45n[R("U/U//5n[R$"U5nUS U2SU24nUS U2UUU-24nUS U2UU-S 24nUn UU- UU--n Un XU--n OeUS:XaP[R*"US5(d [S5e[R$"XQ-5n X-U-n Un Xv-U-n O[SUS35eXXU4$)a( Transform a continuous to a discrete state-space system. Parameters ---------- system : a tuple describing the system or an instance of `lti` The following gives the number of elements in the tuple and the interpretation: * 1: (instance of `lti`) * 2: (num, den) * 3: (zeros, poles, gain) * 4: (A, B, C, D) dt : float The discretization time step. method : str, optional Which method to use: * gbt: generalized bilinear transformation * bilinear: Tustin's approximation ("gbt" with alpha=0.5) * euler: Euler (or forward differencing) method ("gbt" with alpha=0) * backward_diff: Backwards differencing ("gbt" with alpha=1.0) * zoh: zero-order hold (default) * foh: first-order hold (*versionadded: 1.3.0*) * impulse: equivalent impulse response (*versionadded: 1.3.0*) alpha : float within [0, 1], optional The generalized bilinear transformation weighting parameter, which should only be specified with method="gbt", and is ignored otherwise Returns ------- sysd : tuple containing the discrete system Based on the input type, the output will be of the form * (num, den, dt) for transfer function input * (zeros, poles, gain, dt) for zeros-poles-gain input * (A, B, C, D, dt) for state-space system input Notes ----- By default, the routine uses a Zero-Order Hold (zoh) method to perform the transformation. Alternatively, a generalized bilinear transformation may be used, which includes the common Tustin's bilinear approximation, an Euler's method technique, or a backwards differencing technique. The Zero-Order Hold (zoh) method is based on [1]_, the generalized bilinear approximation is based on [2]_ and [3]_, the First-Order Hold (foh) method is based on [4]_. References ---------- .. [1] https://en.wikipedia.org/wiki/Discretization#Discretization_of_linear_state_space_models .. [2] http://techteach.no/publications/discretetime_signals_systems/discrete.pdf .. [3] G. Zhang, X. Chen, and T. Chen, Digital redesign via the generalized bilinear transformation, Int. J. Control, vol. 82, no. 4, pp. 741-754, 2009. (https://www.mypolyuweb.hk/~magzhang/Research/ZCC09_IJC.pdf) .. [4] G. F. Franklin, J. D. Powell, and M. L. Workman, Digital control of dynamic systems, 3rd ed. Menlo Park, Calif: Addison-Wesley, pp. 204-206, 1998. Examples -------- We can transform a continuous state-space system to a discrete one: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import cont2discrete, lti, dlti, dstep Define a continuous state-space system. >>> A = np.array([[0, 1],[-10., -3]]) >>> B = np.array([[0],[10.]]) >>> C = np.array([[1., 0]]) >>> D = np.array([[0.]]) >>> l_system = lti(A, B, C, D) >>> t, x = l_system.step(T=np.linspace(0, 5, 100)) >>> fig, ax = plt.subplots() >>> ax.plot(t, x, label='Continuous', linewidth=3) Transform it to a discrete state-space system using several methods. >>> dt = 0.1 >>> for method in ['zoh', 'bilinear', 'euler', 'backward_diff', 'foh', 'impulse']: ... d_system = cont2discrete((A, B, C, D), dt, method=method) ... s, x_d = dstep(d_system) ... ax.step(s, np.squeeze(x_d), label=method, where='post') >>> ax.axis([t[0], t[-1], x[0], 1.4]) >>> ax.legend(loc='best') >>> fig.tight_layout() >>> plt.show() r rr)methodalphazKFirst argument must either be a tuple of 2 (tf), 3 (zpk), or 4 (ss) arrays.gbtNzUAlpha parameter must be specified for the generalized bilinear transform (gbt) methodzDAlpha parameter must be within the interval [0,1] for the gbt methodg?bilineartusting?euler forward_diffrM backward_diffzohfohimpulsezrrrrrr:r.r-rsk 11155 ^B  ,^Vr#(3