`i$dZddlZddlZddlmZddlZddlmZddlm Z ddl m Z m Z ddl mZmZddlmZmZmZmZmZmZmZdd lmZmZmZmZGd d ZGd d eZGddeZGddeZ Gdde eZ!Gdde eZ"GddeZ#Gdde#eZ$Gdde#eZ%GddeZ&Gdde&eZ'Gd d!e&eZ(d@d#Z)d$Z*dAd%Z+dAd&Z,dBd(Z-dCd*Z.Gd+d,Z/d-Z0d.Z1d/Z2d0Z3d1Z4d2Z5d3Z6dDd7Z7dEd8Z8dAd9Z9dAd:Z:dFd<Z;dBd=Z % % %%';<< <wws###crtd|_d|_d|_dSg Initialize the `lti` baseclass. The heavy lifting is done by the subclasses. N)r__init__inputsoutputs_dt)selfrs r r%zLinearTimeInvariant.__init__ s4   r!c|jS)zAReturn the sampling time of the system, `None` for `lti` systems.r(r)s r dtzLinearTimeInvariant.dt, xr!c&|jiSd|jiS)Nr-)r-r,s r _dt_dictzLinearTimeInvariant._dt_dict1s 7?I$'? "r!c4|jS)zZeros of the system.)to_zpkzerosr,s r r3zLinearTimeInvariant.zeros8{{}}""r!c4|jS)zPoles of the system.)r2polesr,s r r6zLinearTimeInvariant.poles=r4r!cXt|tr|S|S)zConvert to `StateSpace` system, without copying. Returns ------- sys: StateSpace The `StateSpace` system. If the class is already an instance of `StateSpace` then this instance is returned. ) isinstance StateSpaceto_ssr,s r _as_sszLinearTimeInvariant._as_ssBs) dJ ' ' K::<< r!cXt|tr|S|S)aConvert to `ZerosPolesGain` system, without copying. Returns ------- sys: ZerosPolesGain The `ZerosPolesGain` system. If the class is already an instance of `ZerosPolesGain` then this instance is returned. )r8ZerosPolesGainr2r,s r _as_zpkzLinearTimeInvariant._as_zpkPs) dN + + !K;;== r!cXt|tr|S|S)a Convert to `TransferFunction` system, without copying. Returns ------- sys: ZerosPolesGain The `TransferFunction` system. If the class is already an instance of `TransferFunction` then this instance is returned. )r8TransferFunctionto_tfr,s r _as_tfzLinearTimeInvariant._as_tf^s* d, - - K::<< r!)__name__ __module__ __qualname__rr%propertyr-r0r3r6r;r>rB __classcell__rs@r rrs$$$$$     X##X# ##X###X#     ! ! !        r!rc\eZdZdZfdZfdZddZddZddZdd Z dd Z dd Z xZ S)ltia Continuous-time linear time invariant system base class. Parameters ---------- *system : arguments The `lti` class can be instantiated with either 2, 3 or 4 arguments. The following gives the number of arguments and the corresponding continuous-time subclass that is created: * 2: `TransferFunction`: (numerator, denominator) * 3: `ZerosPolesGain`: (zeros, poles, gain) * 4: `StateSpace`: (A, B, C, D) Each argument can be an array or a sequence. See Also -------- scipy.signal.lti ZerosPolesGain, StateSpace, TransferFunction, dlti Notes ----- `lti` instances do not exist directly. Instead, `lti` creates an instance of one of its subclasses: `StateSpace`, `TransferFunction` or `ZerosPolesGain`. If (numerator, denominator) is passed in for ``*system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g., ``s^2 + 3s + 5`` would be represented as ``[1, 3, 5]``). Changing the value of properties that are not directly part of the current system representation (such as the `zeros` of a `StateSpace` system) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_zpk()`` before accessing/changing the zeros, poles or gain. cB|turut|}|dkrtjtg|RS|dkrt jtg|RS|dkrt jt g|RSt dt|S)/Create an instance of the appropriate subclass.zF`system` needs to be an instance of `lti` or have 2, 3 or 4 arguments.)rJlenTransferFunctionContinuousrZerosPolesGainContinuousStateSpaceContinuous ValueErrorr)rrNrs r rz lti.__new__s #::F AAvv19.9179999a/7,7/57777a+34H=5;====!"@AAAwws###r!c4tj|dSr#)rr%)r)rrs r r%z lti.__init__s &!!!!r!Nc(t||||S)zm Return the impulse response of a continuous-time system. See `impulse` for details. X0TrU)impulser)rYrZrUs r r[z lti.impulses ta1----r!c(t||||S)zg Return the step response of a continuous-time system. See `step` for details. rX)stepr\s r r^zlti.steps DR1****r!c(t||||S)zo Return the response of a continuous-time system to input `U`. See `lsim` for details. )rY)lsim)r)UrZrYs r outputz lti.outputs D!Q2&&&&r!dc&t|||S)z Calculate Bode magnitude and phase data of a continuous-time system. Returns a 3-tuple containing arrays of frequencies [rad/s], magnitude [dB] and phase [deg]. See `bode` for details. wn)boder)rfrgs r rhzlti.bodesDA####r!'c&t|||S)z Calculate the frequency response of a continuous-time system. Returns a 2-tuple containing arrays of frequencies [rad/s] and complex magnitude. See `freqresp` for details. re)freqrespris r rlz lti.freqrespsQ''''r!zohc td)zReturn a discretized version of the current system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` z5to_discrete is not implemented for this system class.)rr)r-methodalphas r to_discretezlti.to_discretes"#233 3r!NNNNNrcNrjrmN) rCrDrE__doc__rr%r[r^rbrhrlrrrGrHs@r rJrJms%%L$$$$$&"""""....++++''''$$$$(((( 3 3 3 3 3 3 3 3r!rJceZdZdZfdZfdZedZejdZddZ ddZ dd Z dd Z ddZ xZS)dltia Discrete-time linear time invariant system base class. Parameters ---------- *system: arguments The `dlti` class can be instantiated with either 2, 3 or 4 arguments. The following gives the number of arguments and the corresponding discrete-time subclass that is created: * 2: `TransferFunction`: (numerator, denominator) * 3: `ZerosPolesGain`: (zeros, poles, gain) * 4: `StateSpace`: (A, B, C, D) Each argument can be an array or a sequence. dt: float, optional Sampling time [s] of the discrete-time systems. Defaults to ``True`` (unspecified sampling time). Must be specified as a keyword argument, for example, ``dt=0.1``. See Also -------- scipy.signal.dlti ZerosPolesGain, StateSpace, TransferFunction, lti Notes ----- `dlti` instances do not exist directly. Instead, `dlti` creates an instance of one of its subclasses: `StateSpace`, `TransferFunction` or `ZerosPolesGain`. Changing the value of properties that are not directly part of the current system representation (such as the `zeros` of a `StateSpace` system) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_zpk()`` before accessing/changing the zeros, poles or gain. If (numerator, denominator) is passed in for ``*system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g., ``z^2 + 3z + 5`` would be represented as ``[1, 3, 5]``). cT|tur~t|}|dkrtjtg|Ri|S|dkrt jtg|Ri|S|dkrt jt g|Ri|St dt|S)rLrMrNrOzG`system` needs to be an instance of `dlti` or have 2, 3 or 4 arguments.)rzrPTransferFunctionDiscreterZerosPolesGainDiscreteStateSpaceDiscreterTr)rrrrUrs r rz dlti.__new__s  $;;F AAvv/7,A/5AAA9?AAAa-56LI7=IIIAGIIIa)12D Continuous-time Linear Time Invariant system in zeros, poles, gain form. Represents the system as the continuous time transfer function :math:`H(s)=k \prod_i (s - z[i]) / \prod_j (s - p[j])`, where :math:`k` is the `gain`, :math:`z` are the `zeros` and :math:`p` are the `poles`. Continuous-time `ZerosPolesGain` systems inherit additional functionality from the `lti` class. Parameters ---------- *system : arguments The `ZerosPolesGain` class can be instantiated with 1 or 3 arguments. The following gives the number of input arguments and their interpretation: * 1: `lti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 3: array_like: (zeros, poles, gain) See Also -------- TransferFunction, StateSpace, lti zpk2ss, zpk2tf, zpk2sos Notes ----- Changing the value of properties that are not part of the `ZerosPolesGain` system representation (such as the `A`, `B`, `C`, `D` state-space matrices) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_ss()`` before accessing/changing the A, B, C, D system matrices. Examples -------- Construct the transfer function :math:`H(s)=\frac{5(s - 1)(s - 2)}{(s - 3)(s - 4)}`: >>> from scipy import signal >>> signal.ZerosPolesGain([1, 2], [3, 4], 5) ZerosPolesGainContinuous( array([1, 2]), array([3, 4]), 5, dt: None ) rmNcptt|j|j|jf|||ddd|iS)z Returns the discretized `ZerosPolesGain` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `ZerosPolesGain` rNrr-)r=rr3r6rros r rrz$ZerosPolesGainContinuous.to_discretesX DJ DI>"(!&(((),-   r!rwrrr!r rRrRVs311fr!rRceZdZdZdS)r}a  Discrete-time Linear Time Invariant system in zeros, poles, gain form. Represents the system as the discrete-time transfer function :math:`H(z)=k \prod_i (z - q[i]) / \prod_j (z - p[j])`, where :math:`k` is the `gain`, :math:`q` are the `zeros` and :math:`p` are the `poles`. Discrete-time `ZerosPolesGain` systems inherit additional functionality from the `dlti` class. Parameters ---------- *system : arguments The `ZerosPolesGain` class can be instantiated with 1 or 3 arguments. The following gives the number of input arguments and their interpretation: * 1: `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 3: array_like: (zeros, poles, gain) dt: float, optional Sampling time [s] of the discrete-time systems. Defaults to `True` (unspecified sampling time). Must be specified as a keyword argument, for example, ``dt=0.1``. See Also -------- scipy.signal.ZerosPolesGainDiscrete TransferFunction, StateSpace, dlti zpk2ss, zpk2tf, zpk2sos Notes ----- Changing the value of properties that are not part of the `ZerosPolesGain` system representation (such as the `A`, `B`, `C`, `D` state-space matrices) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_ss()`` before accessing/changing the A, B, C, D system matrices. Nrrr!r r}r}s&&N Dr!r}c`eZdZdZdZdZfdZfdZdZdZ dZ d Z d Z d Z d Zd ZdZdZedZejdZedZejdZedZejdZedZejdZdZdZdZdZxZS)r9a Linear Time Invariant system in state-space form. Represents the system as the continuous-time, first order differential equation :math:`\dot{x} = A x + B u` or the discrete-time difference equation :math:`x[k+1] = A x[k] + B u[k]`. `StateSpace` systems inherit additional functionality from the `lti`, respectively the `dlti` classes, depending on which system representation is used. Parameters ---------- *system: arguments The `StateSpace` class can be instantiated with 1 or 4 arguments. The following gives the number of input arguments and their interpretation: * 1: `lti` or `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 4: array_like: (A, B, C, D) dt: float, optional Sampling time [s] of the discrete-time systems. Defaults to `None` (continuous-time). Must be specified as a keyword argument, for example, ``dt=0.1``. See Also -------- scipy.signal.StateSpace TransferFunction, ZerosPolesGain, lti, dlti ss2zpk, ss2tf, zpk2sos Notes ----- Changing the value of properties that are not part of the `StateSpace` system representation (such as `zeros` or `poles`) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_zpk()`` before accessing/changing the zeros, poles or gain. gY@Nczt|dkr5t|dtr|dS|turI|dt jt g|Ri|Stjtg|Ri|St|S)z4Create new StateSpace object and settle inheritance.rrr-) rPr8rr:r9rrSrr~rrs r rzStateSpace.__new__s v;;!   6!96I J J !9??$$ $ *  zz$'+34HG5;GGG?EGGG*12DE39EEE=CEEEwws###r!ct|dtrdStjdi|d|_d|_d|_d|_t|\|_ |_ |_ |_ dS)z+Initialize the state space lti/dlti system.rNr) r8rrr%_A_B_C_Dr ABCDrs r r%zStateSpace.__init__s{ fQi!4 5 5  F ""6""")7)@&r!c d|jjt|jt|jt|jt|jt|jS)z1Return representation of the `StateSpace` system.z{}( {}, {}, {}, {}, dt: {} )) rrrCrrrrrr-r,s r rzStateSpace.__repr__sY3:: N # LL LL LL LL MM    r!c ~t|ttjtt tjtfSrt)r8r9rndarrayfloatcomplexnumberintr)others r _check_binop_otherzStateSpace._check_binop_other s,%*dlE7"&+s"455 5r!c ,||stSt|tr1t |t |urtS|j|jkrt d|jjd}|jjd}tj tj |j|j |j zftj tj||f|jff}tj |j |jz|j f}tj |j |j|j zf}|j|jz}n"|j}|j |z}|j }|j|z}tj|j|j|j|j}ttj||tj||tj||tj||fi|jS)a] Post-multiply another system or a scalar Handles multiplication of systems in the sense of a frequency domain multiplication. That means, given two systems E1(s) and E2(s), their multiplication, H(s) = E1(s) * E2(s), means that applying H(s) to U(s) is equivalent to first applying E2(s), and then E1(s). Notes ----- For SISO systems the order of system application does not matter. However, for MIMO systems, where the two systems are matrices, the order above ensures standard Matrix multiplication rules apply. z,Cannot multiply systems with different `dt`.rdtype)rNotImplementedr8r9typer- TypeErrorrrrvstackrrrr3r result_typerasarrayr0) r)rn1n2abcd common_dtypes r __mul__zStateSpace.__mul__$s&&u-- "! ! eZ ( (! E{{$t**,,%%w%("" NOOOaBq!B T[$&$&572B)CDD![$*b"X*>*>)HIIKLLA TVeg-uw788A TVTVeg%5677A AAAAAA'!'17KK $,q ===,q ===,q ===,q ===++!M ++ +r!c ||rt|trtS|j}|j}||jz}||jz}tj |j |j |j |j }ttj ||tj ||tj ||tj ||fi|j S)z4Pre-multiply a scalar or matrix (but not StateSpace)r) rr8r9rrrrrrrrrr0r)rrrrrrs r __rmul__zStateSpace.__rmul__`s&&u-- "E:1N1N "! ! F F DFN DFN'!'17KK $,q ===,q ===,q ===,q ===++!M ++ +r!cXt|j|j|j |j fi|jS)z8Negate the system (equivalent to pre-multiplying by -1).)r9rrrrr0r,s r __neg__zStateSpace.__neg__rs,$&$&46'DF7LLdmLLLr!c B||stSt|trt |t |ur=t dt |t ||j|jkrt dt|j |j }tj |j |j f}tj |j|jf}|j|jz}n{tj|}|jj|jkr |j }|j }|j}|j|z}n2t%d|jj|jtj|j|j|j|j}ttj||tj||tj||tj||fi|jS)zM Adds two systems in the sense of frequency domain addition. zCannot add {} and {}z'Cannot add systems with different `dt`.z;Cannot add systems with incompatible dimensions ({} and {})r)rrr8r9rrrr-rrrrrrrr atleast_2drrTrrrr0rs r __add__zStateSpace.__add__vs&&u-- "! ! eZ ( ($ EE{{$t**,, 6 = =d4jj>B5kk!K!KLLLw%("" IJJJ4657++A TVUW-..A TVUW-..A AAOE**Ev|u{**FFFFUN ":"(&u{"C"CEEE'!'17KK $,q ===,q ===,q ===,q ===++!M ++ +r!cf||stS|| Srtrrr rs r __sub__zStateSpace.__sub__s2&&u-- "! !||UF###r!cd||stS||Srtrrs r __radd__zStateSpace.__radd__s0&&u-- "! !||E"""r!cf||stS| |Srtrrs r __rsub__zStateSpace.__rsub__s2&&u-- "! !u%%%r!c||rt|trtSt|tjr|jdkrtd|d|z S)z$ Divide by a scalar rz3Cannot divide StateSpace by non-scalar numpy arraysr) rr8r9rrrndimrTrrs r __truediv__zStateSpace.__truediv__s &&u-- "E:1N1N "! ! eT\ * * GuzA~~EGG G||AeG$$$r!c|jS)z(State matrix of the `StateSpace` system.)rr,s r rz StateSpace.A wr!c.t||_dSrt)rr)r)rs r rz StateSpace.A%a((r!c|jS)z(Input matrix of the `StateSpace` system.)rr,s r rz StateSpace.Brr!c\t||_|jjd|_dS)Nr)rrrrr&)r)rs r rz StateSpace.Bs%%a((fl2& r!c|jS)z)Output matrix of the `StateSpace` system.)rr,s r rz StateSpace.Crr!c\t||_|jjd|_dS)Nr)rrrrr')r)rs r rz StateSpace.Cs$%a((v|A r!c|jS)z.Feedthrough matrix of the `StateSpace` system.)rr,s r rz StateSpace.Drr!c.t||_dSrt)rr)r)rs r rz StateSpace.Drr!cf|j|_|j|_|j|_|j|_dS)z Copy the parameters of another `StateSpace` system. Parameters ---------- system : instance of `StateSpace` The state-space system that is to be copied N)rrrrrs r rzStateSpace._copys,r!c htt|j|j|j|jfi|i|jS)aC Convert system representation to `TransferFunction`. Parameters ---------- kwargs : dict, optional Additional keywords passed to `ss2zpk` Returns ------- sys : instance of `TransferFunction` Transfer function of the current system )r@rrrrrr0r)rs r rAzStateSpace.to_tfsM tw$'"1"1)/"1"1C48MCC Cr!c htt|j|j|j|jfi|i|jS)aO Convert system representation to `ZerosPolesGain`. Parameters ---------- kwargs : dict, optional Additional keywords passed to `ss2zpk` Returns ------- sys : instance of `ZerosPolesGain` Zeros, poles, gain representation of the current system )r=rrrrrr0r$s r r2zStateSpace.to_zpksMvdgtw 0 0(. 0 0B37=BB Br!c*tj|S)z Return a copy of the current `StateSpace` system. Returns ------- sys : instance of `StateSpace` The current system (copy) rr,s r r:zStateSpace.to_ss$rr!)rCrDrErx__array_priority____array_ufunc__rr%rrrrr r rrrrrFrrrrrrrAr2r:rGrHs@r r9r9s+%%PO$$$$$$AAAAA    555:+:+:+x+++$MMM2+2+2+h$$$ ### &&& % % %XX))X)XX''X'XX''X'XX))X)   CCC$BBB$ # # # # # # #r!r9ceZdZdZddZdS)rSa Continuous-time Linear Time Invariant system in state-space form. Represents the system as the continuous-time, first order differential equation :math:`\dot{x} = A x + B u`. Continuous-time `StateSpace` systems inherit additional functionality from the `lti` class. Parameters ---------- *system: arguments The `StateSpace` class can be instantiated with 1 or 3 arguments. The following gives the number of input arguments and their interpretation: * 1: `lti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 4: array_like: (A, B, C, D) See Also -------- scipy.signal.StateSpaceContinuous TransferFunction, ZerosPolesGain, lti ss2zpk, ss2tf, zpk2sos Notes ----- Changing the value of properties that are not part of the `StateSpace` system representation (such as `zeros` or `poles`) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_zpk()`` before accessing/changing the zeros, poles or gain. rmNc|tt|j|j|j|jf|||ddd|iS)z Returns the discretized `StateSpace` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `StateSpace` rNrr-)r9rrrrrros r rrz StateSpaceContinuous.to_discreteTs[=$&$&$&$&)I)+06/46667:rc;! !! !r!rwrrr!r rSrS1s3  D!!!!!!r!rSceZdZdZdS)r~aM Discrete-time Linear Time Invariant system in state-space form. Represents the system as the discrete-time difference equation :math:`x[k+1] = A x[k] + B u[k]`. `StateSpace` systems inherit additional functionality from the `dlti` class. Parameters ---------- *system: arguments The `StateSpace` class can be instantiated with 1 or 3 arguments. The following gives the number of input arguments and their interpretation: * 1: `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 4: array_like: (A, B, C, D) dt: float, optional Sampling time [s] of the discrete-time systems. Defaults to `True` (unspecified sampling time). Must be specified as a keyword argument, for example, ``dt=0.1``. See Also -------- scipy.signal.StateSpaceDiscrete TransferFunction, ZerosPolesGain, dlti ss2zpk, ss2tf, zpk2sos Notes ----- Changing the value of properties that are not part of the `StateSpace` system representation (such as `zeros` or `poles`) is very inefficient and may lead to numerical inaccuracies. It is better to convert to the specific system representation first. For example, call ``sys = sys.to_zpk()`` before accessing/changing the zeros, poles or gain. Nrrr!r r~r~es$$J Dr!r~Tc@ t|tr|}n?t|trt dt|}t j|}t|jdkrtdtt j |j |j |j|jf\}}}} |jd} |jd} |j} |t j| |j j}t j| | f|j j} |ddkr|| d<n?|ddkr$|t)|j|dzz| d<ntd|dup6t|t,t.fo|dkpt j| }| dkrft j| |jz}|s|t j|| jzz }|t j|t j| fS|d|dz }t jt j||std|rt)|j|z}t9d| D]}| |dz |z| |<t j| |jz}|t j|t j| fSt j|}|jdkr |dddf}|jd| krtd |jd| krtd |st jt j||z||zgt j| | | zfg}t)|j}|d| d| f}|| dd| f}t9d| D]"}| |dz |z||dz |zz| |<#n%t j||z||zt j| | fgt jt j| | | zft j | gt j| | d | zzfg}t j|}t)|j}|d| d| f}|| | zdd| f}|| | | zd| f|z }t9d| D].}| |dz |z||dz |zz|||zz| |</t j| |jzt j|| jzz}|t j|t j| fS) a Simulate output of a continuous-time linear system. Parameters ---------- system : an instance of the LTI class or a tuple describing the system. 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) U : array_like An input array describing the input at each time `T` (interpolation is assumed between given times). If there are multiple inputs, then each column of the rank-2 array represents an input. If U = 0 or None, a zero input is used. T : array_like The time steps at which the input is defined and at which the output is desired. Must be nonnegative, increasing, and equally spaced X0 : array_like, optional The initial conditions on the state vector (zero by default). interp : bool, optional Whether to use linear (True, the default) or zero-order-hold (False) interpolation for the input array. Returns ------- T : 1D ndarray Time values for the output. yout : 1D ndarray System response. xout : ndarray Time evolution of the state vector. Notes ----- If (num, den) is passed in for ``system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g. ``s^2 + 3s + 5`` would be represented as ``[1, 3, 5]``). See Also -------- scipy.signal.lsim z3lsim can only be used with continuous-time systems.rzT must be a rank-1 array.rNz Initial time must be nonnegativez"Time steps are not equally spaced.z5U must have the same number of rows as elements in T.z(System does not define that many inputs.rM)!r8rJr;rzAttributeErrorrrrPrrTmaprrrrrsizer3remptyrrZrranysqueezeallcloserrangerrridentity)rrarZrYinterpsysrrrrn_statesn_inputsn_stepsxoutno_inputyoutr-expAT_dtiMexpMTAdBdMlstBd1Bd0s r r`r`sb&#$mmoo FD ! !$()) )6l!!## A 17||q4555T\CE35#%#?@@JAq!QwqzHwqzHfG z Z#%+ . . :w)35; 7 7DtqyyQ 1tAC!A$J'''Q;<<<T  AU|,,8b HQKK !|||D13J'' * DLQS)) )D$,t$$dl4&8&888 1!B =1r * *?=>>>9b>>q'"" + +A1Q3i(*DGG|D13J''$,t$$dl4&8&888 Av{{ aaagJwqzW-.. . wqzXCDDD (I Ka"fa"f%566Xx(/B$CDDF G GQS  9H9ixi' ( 899ixi' (q'"" 3 3A1Q3i"nq1v{2DGG 3 QVQV!Z8(<==?@@ TZ8h3F(GHH!]844677 HhX&=>?? A K  QS  9H9ixi' (HX%&&  12HX00)8);rzr.r&r'rTrrravelrrr3r6r)rrfrgr8rgrYs r rlrls@R&# % f/@ A A #CC..""CC FD ! !%()) )6l""$$ zQ#+**+,, , }#'((DSW]]__cgD99911 C ( (DCIsxdCCC1 a4Kr!ceZdZdZdS)Bunchc :|j|dSrt)__dict__update)r)kwdss r r%zBunch.__init__Rs T"""""r!N)rCrDrEr%rr!r rjrjQs######r!rjc|jdkrtdt|}|jdkrtd|jdkrtd|jd|jdkrtdt ||jdkr,td|jdt |fzt ||jdkr,td t ||jdfzt j|}|D](}t||k|krtd )t}|d vrtd |d kr7t}tt j |std|dkrtd|dkrtd||fS)z Check the poles come in complex conjugage pairs Check shapes of A, B and poles are compatible. Check the method chosen is compatible with provided poles Return update method to use and ordered poles rzPoles must be a 1D array like.rMzA must be a 2D array/matrix.zB must be a 2D array/matrixrzA must be squarez2maximum number of poles is %d but you asked for %dz/number of poles is %d but you should provide %dzFat least one of the requested pole is repeated more than rank(B) times)KNV0YTz0The method keyword must be one of 'YT' or 'KNV0'rpz'Complex poles are not supported by KNV0z#maxiter must be at least equal to 1zrtol can not be greater than 1) rrT_order_complex_polesrrPrr matrix_ranksum_YT_loop _KNV0_loopallisreal) rrr6rprtolmaxiterrSp update_loops r _valid_inputsr}Vs zA~~9:::  ' 'Evzz7888vzz6777wqzQWQZ+,,, 5zzAGAJM'!*c%jj1233 3 5zzAGAJJe**agaj1233 3 ""A 88 qEz??Q  788 8 K ^##KLLL  4;u%%&& HFGG G{{>??? axx9:::  r!ctj|tj|}g}tj|tj|dkD]A}tj||vr)||tj|fBtj||f}|jdt|krtd|S)z Check we have complex conjugates pairs and reorder P according to YT, ie real_poles, complex_i, conjugate complex_i, .... The lexicographic sort on the complex poles is added to help the user to compare sets of poles. rz-Complex poles must come with their conjugates) rsortrxraconjextendrrrPrT)r6 ordered_polesim_polesr{s r rrrrsIeDK$6$6788MH YuTYu--12 3 3// 9Q<<5 OOQ ! - . . .K 9::M {1~]++++HIII r!cJtj||d}tj|d\}}||||jz}||dddfz} tj| ds-| tj| z } | |dd|f<dSdS)z Algorithm "KNV0" Kautsky et Al. Robust pole assignment in linear state feedback, Int journal of Control 1985, vol 41 p 1129->1155 https://la.epfl.ch/files/content/sites/la/files/ users/105941/public/KautskyNicholsDooren raxiscompletemodeNrr)rdeleterqrrZr4norm) rker_poletransfer_matrixjr6transfer_matrix_not_jQR mat_ker_pjyjxjs r _KNV0rs!KCCC ;>>/j> A ADAq!x{},J a2h B =Q  # $+""2&& & "1##r!c t|}t|}|ddddf}|ddddf}||j||jz||jzz z||z}tj|\}} } |jdddddf\} } | dddddf\} }tj|dd|df|dd|dff}tj| d| ds-||| z}||| z}tj||f}ntjtj||tj||j ftjtj||j ||ff}tjtj| | ftj| |ff}||z}||jz|z}tj|dstd|ztj |z }|d|dd|fj ddf|dd|f<||dd|fj dddf|dd|f<dS|d|dd|fj ddf|dd|f<||dd|fj dddf|dd|f<dS)zM Applies algorithm from YT section 6.1 page 19 related to real pairs NrrMrr) rrZrrsvdrr4rr3rrr)rrrr@rrvmumsmvmmu1mu2nu1nu2&transfer_matrix_j_mo_transfer_matrix_jker_pole_imo_mu1ker_pole_i_nu1ker_pole_mu_nu ker_pole_ij mu_nu_matrixtransfer_matrix_ijs r _YT_realrsX AA AA !!!R+A !!!R+A !!ac'AG+ , ;A##JBBtBQB4K HC"1"aaa+HC.2[1d #1d #:%.&.&* =A1 & &4#A;,!!s*&6%GHHk K!HQK$5668 9 9 KHQK$566!!& ' '#   { [#s $ $dk3*&=&= >  %|3)N,<<BC =+Q / / "1gg(::"k../ABBC 2 +_QQQT " ( + +Q .! 1!3 AAAqD ! ' * + +Q .! 1!/ +_QQQT " ( + +Q .! 1!/ AAAqD ! ' * + +Q .! 1r!ctd|ddddfz}td|ddddfz}|d|zz}||}|j||jz||jzz z|z} ddl} | j| \} } tj| tj| } } tj tj | } | dd| ddf}| dd| ddf}|dd|dfd|dd|dfzz}tj tj | | dtj | | ds||z}ntj ||f}||z}tj ||jz|}tj |dsn|tj|z }tj|dddf|dd|f<tj|dddf|dd|f<dStj|dddf|dd|f<tj|dddf|dd|f<dS)zP Applies algorithm from YT section 6.2 page 20 related to complex pairs rMNrr?r)rrrZrKreigrrrargsortrNr4rdotrrOra)rrrr@ruruirrrrQe_vale_vec e_val_idxrrr ker_pole_mumu1_mu2_matrixtransfer_matrix_i_js r _YT_complexrs a1QQQD[> !B a1QQQD[> !B RU A1+K AFFHHJAC ?@;NA 9==))LE5<&& U(;(;5E TXe__--I 9R=$& 'C 9R=$& 'C 1d # ?111a: && '+ =% " "677% " "677 9 93!C' c3Z00!N2 (K+2B2B2D2D2F$F#IKK =,a 0 0=2#{//0CDD E $ *=aaad*C D D1 $ *=aaad*C D D1!% +aaad*; < <1 $ +aaad*; < <1r!c0|tj|jd}|dz}|dkr+tj|gtjdgg}nggg}tj|dzt |dzd} tjd||dzz} |dd| z|dd| zdz|d| |d| dztjd|dz} |dd| zdz |dd| z|dkrttj|drZ|dtjd|dtjd|d| |d| dztjd||dzz} | D]u} td|dzD]_} |dtj| |dtj| | z`v|dkrttj|drZ|dtjd|dtjd|d| |d| dztjd||dzz} | D]} t|dz|dzD]o} | | z}||kr| | z|z }|dtj| |dtj|p|dkrttj|drZ|dtjd|dtjd|d| |d| dztd|dzD]_} |dtj| |dtj| |z`|dkrttj|drZ|dtjd|dtjd|d| |d| dztj|j dz }d}d}||kr|s~tj tj |}|D]\} } t| t| } } | | krH| dks Jdtj|| s Jdt|||| |rtt|jd}|| || dz |dd|f}tj |d \}}tj|| rItj|| sJd t%|zt'|||| | Yd t%|z}tj|| s J|t)|||| | t+tjtjj}t3|tj tj |f}tj ||z |z }||kr||krd }|dz }||kr|~|||fS) z Algorithm "YT" Tits, Yang. Globally Convergent Algorithms for Robust Pole Assignment by State Feedback https://hdl.handle.net/1903/5598 The poles P have to be sorted accordingly to section 6.2 page 20 rrMrFzi!=0 for KNV call in YTzcalling KNV on a complex poleNrrz"mixing real and complex in YT_realT)rrxrarrayarangerPrappendr5rZrNrdetrrlistrrstrrrrfinfofloat64epsmax)rrr6rrzrynb_realhnb update_orderr_compr_pr_jrr@idx_1stopnb_trydet_transfer_matrixbidxtransfer_matrix_not_i_jrrXmsg sq_spacingdet_transfer_matrixcur_rtols r ruruNsDK&&'-a0G Q,C {{G,,- 1 ? Bx [CJJqL! 4 4F +aWq[ ) )CO1S5!!!O1S57###O6"""O6!8$$$ +aQ  CO1S57###O1S5!!! axxDKa))xQtz!}}---Qtz!}}---O6"""O6!8$$$ +aWq[ ) )C 44q#a% 4 4A O " "4:a== 1 1 1 O " "4:ac?? 3 3 3 3 4 axxDKa))xQtz!}}---Qtz!}}---O6"""O6!8$$$ +aWq[ ) )C 66s1ugai(( 6 6AaCEw!G  O " "4:a== 1 1 1 O " "4:e#4#4 5 5 5 5  6 axxDKa))xQtz!}}---Qtz!}}---O6"""O6!8$$$ 1c!e__22Qtz!}}---Qtz!C%001111 axxDKa))xQtz!}}---Qtz!}}---O6"""O6!8$$$:l++-a/L D F 7  4 #x (H(HII  D DDAqq663q66qAAvvAvvv8vvv{58,,MM.MMM,a?Au====5!6q!9::;; ! *9!!!S&*A'{~~&=J~OO1;uQx((D;uQx00223%'*5zz32220Xq/1a@@@@>UKC Ka111663661!_aCCCC$*T\22677 !:"&(4;???+K+K"L"L#NOO8 !"  !! d??2Z??D! Y 7  4 Z 6 !!r!cPd}d}||kr|stjtj|}t |jdD]} t |||| |tttjtj j } t| tjtj|f} tj| |z | z } | |kr| | krd}|dz }||kr||| |fS)zI Loop over all poles one by one and apply KNV method 0 algorithm FrTr) rrNrrr5rrrrrrr) rrr6rrzryrrrrrrrs r rvrvs0 D F 7  4 #x (H(HIIqwqz"" : :A !X5 9 9 9 9$tz$,77;<<== !:"&(4;???+K+K"L"L#NOO803GG/011 d??2Z??D!  7  4  6 !!r!rqMbP?c X t||||||\}}d}d}tj|d\} } tj|} | ddd| f} | dd| df} | d| ddf} |jd| kr9tj|j}d}||jdkr||}tj||||f<tj|r]tj | |||dzf<tj|||dz|dzf<tj |||dz|f<|dz }|dz }||jdktj |||z dd}tj |jd}tj }tj }n(g}d}t|jdD]s}|rd}tj| j|||tj |jdzz j}tj|d\}}|dd|jddf}tj|d dddf}|tj|z }tj||rTtjtj|tj |g}|||gd }n|||dkr|}]tj||f}u| dkr;|||||||\}}}|s%|dkrd |d |d }t+j|d|t0}d}||jddz krtj||rS|dd|f}|dd|dzf}|d|zz |dd|f<|d|zz|dd|dzf<|dz }|dz }||jddz k tj|jtj||jzj}tj| | j||z z}n,#tjj$r} t;d| d} ~ wwxYw| }tj|}t=}!||!_|||zz }"ddl!}#|#j"|"d}tGtj$|}$|$|!_%||!_&||!_'||!_(||!_)|!S)a Compute K such that eigenvalues (A - dot(B, K))=poles. K is the gain matrix such as the plant described by the linear system ``AX+BU`` will have its closed-loop poles, i.e the eigenvalues ``A - B*K``, as close as possible to those asked for in poles. SISO, MISO and MIMO systems are supported. Parameters ---------- A, B : ndarray State-space representation of linear system ``AX + BU``. poles : array_like Desired real poles and/or complex conjugates poles. Complex poles are only supported with ``method="YT"`` (default). method: {'YT', 'KNV0'}, optional Which method to choose to find the gain matrix K. One of: - 'YT': Yang Tits - 'KNV0': Kautsky, Nichols, Van Dooren update method 0 See References and Notes for details on the algorithms. rtol: float, optional After each iteration the determinant of the eigenvectors of ``A - B*K`` is compared to its previous value, when the relative error between these two values becomes lower than `rtol` the algorithm stops. Default is 1e-3. maxiter: int, optional Maximum number of iterations to compute the gain matrix. Default is 30. Returns ------- full_state_feedback : Bunch object full_state_feedback is composed of: gain_matrix : 1-D ndarray The closed loop matrix K such as the eigenvalues of ``A-BK`` are as close as possible to the requested poles. computed_poles : 1-D ndarray The poles corresponding to ``A-BK`` sorted as first the real poles in increasing order, then the complex congugates in lexicographic order. requested_poles : 1-D ndarray The poles the algorithm was asked to place sorted as above, they may differ from what was achieved. X : 2-D ndarray The transfer matrix such as ``X * diag(poles) = (A - B*K)*X`` (see Notes) rtol : float The relative tolerance achieved on ``det(X)`` (see Notes). `rtol` will be NaN if it is possible to solve the system ``diag(poles) = (A - B*K)``, or 0 when the optimization algorithms can't do anything i.e when ``B.shape[1] == 1``. nb_iter : int The number of iterations performed before converging. `nb_iter` will be NaN if it is possible to solve the system ``diag(poles) = (A - B*K)``, or 0 when the optimization algorithms can't do anything i.e when ``B.shape[1] == 1``. Notes ----- The Tits and Yang (YT), [2]_ paper is an update of the original Kautsky et al. (KNV) paper [1]_. KNV relies on rank-1 updates to find the transfer matrix X such that ``X * diag(poles) = (A - B*K)*X``, whereas YT uses rank-2 updates. This yields on average more robust solutions (see [2]_ pp 21-22), furthermore the YT algorithm supports complex poles whereas KNV does not in its original version. Only update method 0 proposed by KNV has been implemented here, hence the name ``'KNV0'``. KNV extended to complex poles is used in Matlab's ``place`` function, YT is distributed under a non-free licence by Slicot under the name ``robpole``. It is unclear and undocumented how KNV0 has been extended to complex poles (Tits and Yang claim on page 14 of their paper that their method can not be used to extend KNV to complex poles), therefore only YT supports them in this implementation. As the solution to the problem of pole placement is not unique for MIMO systems, both methods start with a tentative transfer matrix which is altered in various way to increase its determinant. Both methods have been proven to converge to a stable solution, however depending on the way the initial transfer matrix is chosen they will converge to different solutions and therefore there is absolutely no guarantee that using ``'KNV0'`` will yield results similar to Matlab's or any other implementation of these algorithms. Using the default method ``'YT'`` should be fine in most cases; ``'KNV0'`` is only provided because it is needed by ``'YT'`` in some specific cases. Furthermore ``'YT'`` gives on average more robust results than ``'KNV0'`` when ``abs(det(X))`` is used as a robustness indicator. [2]_ is available as a technical report on the following URL: https://hdl.handle.net/1903/5598 See Also -------- scipy.signal.place_poles References ---------- .. [1] J. Kautsky, N.K. Nichols and P. van Dooren, "Robust pole assignment in linear state feedback", International Journal of Control, Vol. 41 pp. 1129-1155, 1985. .. [2] A.L. Tits and Y. Yang, "Globally convergent algorithms for robust pole assignment by state feedback", IEEE Transactions on Automatic Control, Vol. 41, pp. 1432-1452, 1996. rrrNrr)rcondFrTzSConvergence was not reached after maxiter iterations. You asked for a tolerance of z , we got .rM) stacklevelrzfThe poles you've chosen can't be placed. Check the controllability matrix and try another set of poles)*r}rrrrsrr3rOrxralstsqeyenanr5rrZrtrrrrwarningswarnastyperrsolvediag LinAlgErrorrTrj gain_matrixrrKrrrrcomputed_polesrequested_polesrWrynb_iter)%rrr6rpryrzr|rrrzrankBu0u1 diag_polesrr{rrrskip_conjugater pole_space_jrrX ker_pole_jtransfer_matrix_jrerr_msgrelimgrefull_state_feedbacktemprQrs% r place_polesrs1Z'q!UFD'JJKHG ;>>!*> - -DAq K # #A & &E 111fuf9B 111eff9B &5&!!!) A wqzU(Z(( EKN""c A#'9Q<>,Z>@@DAq111l034445J$!%! < < toutu_dtr@s r rr sV&#3()) )  % %3vcrc{2vbz22VZ00K ]]__F Av{{ OA   y!ff !Ovy0R5$*X %9::;;a?  :{FHN1$56 7 7D :{FHN1$56 7 7D =hK 8 8 8D zZ!2 455QT \"%%QT  y qw<<1  !!!T' A,!!Q!,,,T221kAo & &CCx$q!!!t*,vx$q!!!t*/DDQqS!!!V XQT *VXQT -BBQT %hk!mQQQ.>)??$hk!mQQQ.>)??@DQ T4Tzr!cht|tr|}nPt|trt dt|ddd|di}|d}|!t jd||jz|d}nt j|}d}td|j D]b}t j |j d|j f}d |d|f<t|||| }| |d f}n ||d fz}|d}c||fS) a Impulse response of discrete-time system. Parameters ---------- system : tuple of array_like or instance of `dlti` A tuple describing the system. The following gives the number of elements in the tuple and the interpretation: * 1: (instance of `dlti`) * 3: (num, den, dt) * 4: (zeros, poles, gain, dt) * 5: (A, B, C, D, dt) x0 : array_like, optional Initial state-vector. Defaults to zero. t : array_like, optional Time points. Computed if not given. n : int, optional The number of time points to compute (if `t` is not given). Returns ------- tout : ndarray Time values for the output, as a 1-D array. yout : tuple of ndarray Impulse response of system. Each element of the tuple represents the output of the system based on an impulse in each input. See Also -------- scipy.signal.dimpulse impulse, dstep, dlsim, cont2discrete z:dimpulse can only be used with discrete-time dlti systems.Nrr-rcrFendpointrIrrr)r8rzr;rJr.rrPr-rr5r&r3rr rrrrgr>r@r one_outputrs r rrt sUJ&$< FC <-.. .vcrc{2vbz2299;; y  y M!Q]A > > > LOO D 1fm $ $   J FM2 3 3!Q$61b111 <qM#DD:a=**D!} :r!ct|tr|}nPt|trt dt|ddd|di}|d}|!t jd||jz|d}nt j|}d}td|j D]}t j |j d|j f}t j |j df|dd|f<t|||| }| |d f}n ||d fz}|d}||fS) a Step response of discrete-time system. Parameters ---------- system : tuple of array_like A tuple describing the system. The following gives the number of elements in the tuple and the interpretation: * 1: (instance of `dlti`) * 3: (num, den, dt) * 4: (zeros, poles, gain, dt) * 5: (A, B, C, D, dt) x0 : array_like, optional Initial state-vector. Defaults to zero. t : array_like, optional Time points. Computed if not given. n : int, optional The number of time points to compute (if `t` is not given). Returns ------- tout : ndarray Output time points, as a 1-D array. yout : tuple of ndarray Step response of system. Each element of the tuple represents the output of the system based on a step response to each input. See Also -------- scipy.signal.dlstep step, dimpulse, dlsim, cont2discrete z7dstep can only be used with discrete-time dlti systems.Nrr-rcrFrrr)r8rzr;rJr.rrPr-rr5r&r3rr[rrs r rr skJ&$< FC <()) )vcrc{2vbz2299;; y  y M!Q]A > > > LOO D 1fm $ $   J FM2 3 3)QWQZM**!!!Q$61b111 <qM#DD:a=**D!} :r!Fct|ts>t|trtdt|ddd|di}t|tr|}t|t tfstd|j dks |j dkrtd||}n|}t|t rQt |j |j\}}t||||\}}n;t|tr&t!|j|j|j||\}}||fS) a. Calculate the frequency response of a discrete-time system. Parameters ---------- system : an instance of the `dlti` class or a tuple describing the system. The following gives the number of elements in the tuple and the interpretation: * 1 (instance of `dlti`) * 2 (numerator, denominator, dt) * 3 (zeros, poles, gain, dt) * 4 (A, B, C, D, dt) w : array_like, optional Array of frequencies (in radians/sample). Magnitude and phase data is calculated for every value in this array. If not given a reasonable set will be calculated. n : int, optional Number of frequency points to compute if `w` is not given. The `n` frequencies are logarithmically spaced in an interval chosen to include the influence of the poles and zeros of the system. whole : bool, optional Normally, if 'w' is not given, frequencies are computed from 0 to the Nyquist frequency, pi radians/sample (upper-half of unit-circle). If `whole` is True, compute frequencies from 0 to 2*pi radians/sample. Returns ------- w : 1D ndarray Frequency array [radians/sample] H : 1D ndarray Array of complex magnitude values See Also -------- scipy.signal.dfeqresp Notes ----- If (num, den) is passed in for ``system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g. ``z^2 + 3z + 5`` would be represented as ``[1, 3, 5]``). z6dfreqresp can only be used with discrete-time systems.Nrr-zUnknown system typerz?dfreqresp requires a SISO (single input, single output) system.)rgr)r8rzrJr.r9rBr@r=rTr&r'rrrhrrrr3r6r)rrfrgrrgrrrYs r rr sZ fd # #3 fc " " ; ":;; ;vcrc{2vbz22&*%%! f/@ A A0./// }V^q00+,, , }&*++&$..vz/?/?/A/A6:NNSS#D66611 FN + +&v|V[t$&&&1 a4Kr!c>t|||\}}t|tr|j}n|d}dt jt |z}t jt jt j |}||z ||fS)aD Calculate Bode magnitude and phase data of a discrete-time system. Parameters ---------- system : an instance of the LTI class or a tuple describing the system. The following gives the number of elements in the tuple and the interpretation: * 1 (instance of `dlti`) * 2 (num, den, dt) * 3 (zeros, poles, gain, dt) * 4 (A, B, C, D, dt) w : array_like, optional Array of frequencies (in radians/sample). Magnitude and phase data is calculated for every value in this array. If not given a reasonable set will be calculated. n : int, optional Number of frequency points to compute if `w` is not given. The `n` frequencies are logarithmically spaced in an interval chosen to include the influence of the poles and zeros of the system. Returns ------- w : 1D ndarray Frequency array [rad/time_unit] mag : 1D ndarray Magnitude array [dB] phase : 1D ndarray Phase array [deg] See Also -------- scipy.signal.dbode Notes ----- If (num, den) is passed in for ``system``, coefficients for both the numerator and denominator should be specified in descending exponent order (e.g. ``z^2 + 3z + 5`` would be represented as ``[1, 3, 5]``). rerr]) rr8rzr-rr^rNrad2degr_angle)rrfrgrcr-rdres r rrY sV VqA & & &DAq&$ Y BZ CFF## #C LTZ]]33 4 4E r63 r!rmc t|dkr|St|dkr[tt|d|d|||}t |d|d|d|d|fzSt|dkrbtt |d|d|d|||}t |d|d|d|d|fzSt|dkr|\}}}}ntd|dkr,|td |dks|dkrtd |dkrtj |j d||z|zz } tj |j dd |z |z|zz} tj | | } tj | ||z} tj | j |j } | j } |||| zzz}n|d ks|dkrt||ddS|dks|dkrt||ddS|dkrt||dd S|dkrtj||f}tjtj|j d|j dftj|j d|j dff}tj||f}t#||z}|d |j dd d f}|d d d|j df} |d d |j dd f} |} |}nH|dkr|j d}|j d}t%tj||g|ztj |}tj||d|zzf}tj||g}tj|}|d |d|f}|d ||||zf}|d |||zd f}|} ||z ||zz} |} |||zz}na|dkrItj|dstdt#||z} | |z|z} |} ||z|z}ntd|z| | | ||fS)aM 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. See Also -------- scipy.signal.cont2discrete rrMrrrNrOzKFirst 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 methodrIbilineartusting?euler forward_diffr- backward_diffrmfohr[z;Impulse method is only applicableto strictly proper systemsz"Unknown transformation method '%s')rPrrrr rr rrTrrrrrrZrr3rrrr4)rr-rprqsysdrrrrimarhsadbdcdddem_upperem_loweremmsrgrms11ms12ms13s r rr sLn 6{{a!!### 6{{aU6!9fQi88"V#(***T!Wd1gtAwQ88B5@@ V  VF1Ivay&)DDb$*%999d1gtAwQa99REAA V   1a677 7 =KLL L QYY%!))899 9hqwqz""U2XaZ/hqwqz""cEk2%5a%77 [  sC ( ( [  sBqD ) )[  suac * * T B  :  8!3!3VRSAAAA 7  f66VRSAAAA ? " "VRSAAAA 5;1v&&; AGAJ +C D D $ AGAJ +C D D FGG[(H- . . "r']]  QQQ  1QWQZ<  171:;;    5 GAJ GAJdk1a&11B6 DD:q!a!e)n--[(H- . . [__"1"ac'{"1"aAg+"1"a!eff*~  D[4$; &  T\ 9  }Q"" ;:;; ;!b&\\ !Vb[  URZ=FGGG r2r2 r!)NTrsrurv)rqrr)NNrrw)>rxrrmathrr cupyx.scipyrcupyx.scipy.interpolatercupyx.scipy.linalgrr"cupyx.scipy.signal._lti_conversionrr *cupyx.scipy.signal._iir_filter_conversionsr r r r rrr!cupyx.scipy.signal._filter_designrrrrrrJrzr@rQr|r=rRr}r9rSr~r`rUr[r^rhrlrjr}rrrrrrurvrrrrrrrrr!r r(sX  666666////////))))))))==================((((((((((((S S S S S S S S lt3t3t3t3t3 t3t3t3ny6y6y6y6y6 y6y6y6xXXXXX*XXXv:':':':':'!13:':':'z, , , , , /, , , ^l+l+l+l+l+(l+l+l+^CCCCC~sCCCL( ( ( ( ( ^T( ( ( Vg#g#g#g#g#$g#g#g#T 1!1!1!1!1!:s1!1!1!h& & & & & T& & & V[5[5[5[5|& & & R<<<<~8888v1111hEEEEX######## ///d("#"#"#`C C C L9=9=9=xA"A"A"H"""8]]]]D aaaaHGGGGTGGGGTNNNNb5555t^^^^^^r!