+ nDjLRt^RIt^RIHtHtHtHtHtHtH t H t H t ^RI H t ^RIHtHtHtHt^RIHuHt^RIHtHtHt.R OtRtR RltRRltR tRR lt RR lt!R#)zr ltisys -- a collection of functions to convert linear time invariant systems from one representation to another. N) r_eye atleast_2dpolydotasarrayzerosarrayouter)linalg)array_namespacexp_size xp_promotexp_result_type)tf2zpkzpk2tf normalizec\W4wr\VP4pV^8Xd\V.VP4pVP^,p\V4pW48dRp\ V4hV^8XgV^8Xd?\ .\4\ .\4\ .\4\ .\43#\P!\P!VP^,WC, 3VPR7V34pVPR,^8d\VR,4pM\ ^..\4pV^8XdcVPVP4p\R4\^VP^,34\VP^,^34V3#\ VR,.4)p\V\V^, V^, 43,p\V^, ^4p VR,\VR,VR,4, p VPV P^,V P^,34pWW3#)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.]]) z7Improper transfer function. `num` is longer than `den`.dtypeNNNNN)rr)rr)rlenshaperr ValueErrorr floatnphstackrrreshaperrr ) numdennnMKmsgDfrowABCs && V/data/cameron/venvs/s3viz/lib/python3.14/site-packages/scipy/signal/_lti_conversion.pytf2ssr/sp"HC SYYB QwseSYY' ! A CAuGoAvab% %E"2E"e4Db% " " ))RXXsyy|QU3399EsK LC yy}q s4y ! A3% Av IIcii f ua_5qwwqz1o&+ + 3r7)  D 4QUAE" "#A AE1 A E U3t9c"g..A 1771:qwwqz*+A :c aaVfVfVf \R4hVfVf \R4hVfVf \R4h\WW#4o\WW#SRR7wrr#\WW#SR7oVV3RlWW#34wrr#VP^,;'g/VP^,;'gVP^,pVP^,;'gVP^,pVP^,;'gVP^,p\ V4^8XdSP WD3SR7MTp\ V4^8XdSP WE3SR7MTp\ V4^8XdSP Wd3SR7MTp\ V4^8XdSP We3SR7MTpVPWD38wd \R VP R V R V R 24hVPWE38wd \R VP R V R V R 24hVPWd38wd \RVP R V R V R 24hVPWe38wd \RVP R V R V R 24hWW#3#)a Check state-space matrices compatibility and ensure they are 2d arrays. First, the input matrices are converted into two-dimensional arrays with appropriate dtype as needed. Then the dimensions n, q, p are determined by investigating the array shapes. If an input is ``None``, or has size zero, it is set to an array of zeros of compatible shape. Finally, it is verified that all parameter shapes are compatible with each other. If that fails, a ``ValueError`` is raised. Note that the dimensions n, q, p are allowed to be zero. Parameters ---------- A : array_like, optional Two-dimensional array of shape (n, n). B : array_like, optional Two-dimensional array of shape (n, p). C : array_like, optional Two-dimensional array of shape (q, n). D : array_like, optional Two-dimensional array of shape (q, p). Returns ------- A, B, C, D : array State-space matrices as two-dimensional arrays with identical dtype. The result dtype is determined based on the standard `dtype promotion rules `_ except for when the inputs are all of integer dtype, in which case the returned arrays will have the default floating point dtype of ``float64``. Raises ------ ValueError If the dimensions n, q, or p could not be determined or if the shapes are incompatible with each other. Notes ----- If a matrix is not modified, the original matrix (not a copy) is returned. The :ref:`tutorial_signal_state_space_representation` section of the :ref:`user_guide` presents the corresponding definitions of continuous-time and disrcete time state space systems. See Also -------- StateSpace: Linear Time Invariant system in state-space form. dlti: Discrete-time linear time invariant system base class. tf2ss: Transfer function to state-space representation. ss2tf: State-space to transfer function. ss2zpk: State-space representation to zero-pole-gain representation. cont2discrete: Transform a continuous to a discrete state-space system. Examples -------- The following example demonstrates that the passed lists are converted into two-dimensional arrays: >>> from scipy.signal import abcd_normalize >>> AA, BB, CC, DD = abcd_normalize(A=[[1, 2], [3, 4]], B=[[-1], [5]], ... C=[[4, 5]], D=2.5) >>> AA.shape, BB.shape, CC.shape, DD.shape ((2, 2), (2, 1), (1, 2), (1, 1)) In the following, the missing parameter C is assumed to be an array of zeros with shape (1, 2): >>> from scipy.signal import abcd_normalize >>> AA, BB, CC, DD = abcd_normalize(A=[[1, 2], [3, 4]], B=[[-1], [5]], D=2.5) >>> AA.shape, BB.shape, CC.shape, DD.shape ((2, 2), (2, 1), (1, 2), (1, 1)) >>> CC array([[0., 0.]]) z9Dimension n is undefined for parameters A = B = C = None!z5Dimension p is undefined for parameters B = D = None!z5Dimension q is undefined for parameters C = D = None!T)xpforce_floating)r2c3<"TFDpVe)\P!SPV4^SR7MSPRSR7xKF R#5i)N)ndimr2r)rr)xpx atleast_ndrr).0M_rr2s& r. !abcd_normalize..sKB > rzz"~A"5!xxex< =sA ArzParameter A has shape z but should be (z, z)!zParameter B has shape zParameter C has shape zParameter D has shape )rr rrrr r) r+r,r-r)npqrr2s &&&& @@r.abcd_normalizer?vs]V yQY19TUUyQYPQQyQYPQQ q $BA!2dCJA! 1" -E,JA!  ..aggaj..AGGAJA    aggajA    aggajA*1q!u%aA)0q!u%aA)0q!u%aA)0q!u%aAww1&1!'':J1#RPQsRTUVVww1&1!'':J1#RPQsRTUVVww1&1!'':J1#RPQsRTUVVww1&1!'':J1#RPQsRTUVV :r0cF\WW#4wrr#VPwrVWF8d \R4hVRWD^,13,pVRWD^,13,p\V4pVP^8XdOVP^8Xd>\ P !V4pVP^8XdVP^8Xd.pW3#VP^,p VR,VR,,VR,,V,R,p \ P!WY^,3V P4p\V4FNp \W+R3,4p \V\W4, 4W;,^, V,,W&KP W3# \d^pEL>i;i)a.State-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. Notes ----- Before calculating `num` and `den`, the function `abcd_normalize` is called to convert the parameters `A`, `B`, `C`, `D` into two-dimesional arrays of the same dtype. The resulting dtype will be based on NumPy's dtype promotion rules, except in the case where each of `A`, `B`, `C`, and `D` has integer dtype, in which case the resulting dtype will be the default floating point dtype of ``float64``. The :ref:`tutorial_signal_state_space_representation` section of the :ref:`user_guide` presents the corresponding definitions of continuous-time and disrcete time state space systems. 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.rr)rr) r?rrrsizer ravelemptyrrangerr) r+r,r-r)inputnoutninr$r# num_states type_testkCks &&&&& r.ss2tfrMs^L a+JA!ID |DEE !U19_ A !U19_ A1g ! !&&A+hhqk FFaKaffkCxJ$!D'!AdG+a/#5I ((Dq.)9?? ;C 4[ Q$ a#a*n%S(88 8O! s F F F c(\\WV4!#)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. )r/r)zr=rKs&&&r.zpk2ssrPNs" &q/ ""r0c ,\\WW#VR7!#)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. )rF)rrM)r+r,r-r)rFs&&&&&r.ss2zpkrRbs6 5q51 22r0cn \VR4'd/\VP4'dVPWVR7#\V4^8XdY\ \ V^,V^,4WVR7p\ V^,V^,V^,V^,4V3,#\V4^8Xda\ \V^,V^,V^,4VW#R7p\V^,V^,V^,V^,4V3,#\V4^8XdVwrVrxM \R4hVR8Xd)Vf \R4hV^8gV^8d \R4hVR8XEd\P!VP^,4W1,V,, p \P!V \P!VP^,4R V, V,V,,4p \P!WV,4p \P!V P4VP44p V P4p W\P !W{4,,p EM)VR 8XgVR 8Xd\ WRR R7#VR 8XgVR8Xd\ WRRR7#VR8Xd\ WRR R7#VR8XEd4\P"!WV34p\P"!\P$!VP^,VP^,34\P$!VP^,VP^,3434p\P&!W34p\P(!VV,4pVRVP^,1R3,pVR^VP^,13,p VRVP^,R13,p Tp Tp EMVR8XEdVP^,pVP^,p\P*!\P,!WV.4V,\P!V44p\%VV^V,,34p\P,!V.V..4p\P(!V4pVRV1^V13,pVRV1VVV,13,pVRV1VV,R13,pTp VV, VV,,p Tp WV,,p M{VR8Xdf\P.!V^4'g \R4h\P(!WQ,4p W,V,p Tp Wv,V,p M\RV R24hWWV3#)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() to_discrete)dtmethodalpha)rVrWzKFirst 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_diffrA backward_diffzohrfohimpulsezrsc 11133--55 ^BpfbJ#(3