(ph#SrSSKrSSKJr SSKJr SSKJr SSK J r J r J r J r JrJrJr SSKJrJrJrJrJrJrJr SSKrSS KJrJrJrJrJrJ r J!r!J"r"J#r# SSK$r$/S Qr%"S S 5r&"S S\&5r'"SS\&5r("SS\&5r)"SS\)\'5r*"SS\)\(5r+"SS\&5r,"SS\,\'5r-"SS\,\(5r."SS\&5r/"SS \/\'5r0"S!S"\/\(5r1S8S#jr2S$r3S9S%jr4S9S&jr5S:S'jr6S;S(jr7"S)S*5r8S+r9S,r:S-r;S.rS1r?SS6jrDS:S7jrEg)?z] ltisys -- a collection of classes and functions for modeling linear time invariant systems. N)qr)linalg)make_interp_spline)tf2zpkzpk2tf normalizefreqsfreqz freqs_zpk freqz_zpk)tf2ssabcd_normalizess2tfzpk2ssss2zpk cont2discrete_atleast_2d_or_none) real atleast_1dsqueezeasarrayzerosdot transposeoneslinspace)ltidltiTransferFunctionZerosPolesGain StateSpacelsimimpulsestepbodefreqresp place_polesdlsimdstepdimpulse dfreqrespdbodec^\rSrSrU4SjrU4Sjr\S5r\S5r\S5r \S5r Sr S r S r S rU=r$) LinearTimeInvariant.cJ>U[La [S5e[TU] U5$)z2Create a new object, don't allow direct instances.z\The LinearTimeInvariant class is not meant to be used directly, use `lti` or `dlti` instead.)r/NotImplementedErrorsuper__new__clssystemkwargs __class__s G/var/www/html/venv/lib/python3.13/site-packages/scipy/signal/_ltisys.pyr4LinearTimeInvariant.__new__/s/ % %%';< <ws##cL>[TU]5 SUlSUlSUlgO Initialize the `lti` baseclass. The heavy lifting is done by the subclasses. N)r3__init__inputsoutputs_dt)selfr9s r:r@LinearTimeInvariant.__init__7s%   r<cUR$)zAReturn the sampling time of the system, `None` for `lti` systems.rCrDs r:dtLinearTimeInvariant.dtC xxr<c<URc0$SUR0$)NrI)rIrHs r:_dt_dictLinearTimeInvariant._dt_dictHs 77?I$''? "r<c6UR5R$)zZeros of the system.)to_zpkrrHs r:rLinearTimeInvariant.zerosO{{}"""r<c6UR5R$)zPoles of the system.)rPpolesrHs r:rTLinearTimeInvariant.polesTrRr<cP[U[5(aU$UR5$)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. ) isinstancer"to_ssrHs r:_as_ssLinearTimeInvariant._as_ssYs" dJ ' 'K::< r<cP[U[5(aU$UR5$)zConvert 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. )rWr!rPrHs r:_as_zpkLinearTimeInvariant._as_zpkgs" dN + +K;;= r<cP[U[5(aU$UR5$)zConvert 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. )rWr to_tfrHs r:_as_tfLinearTimeInvariant._as_tfus# d, - -K::< r<)rCrArB)__name__ __module__ __qualname____firstlineno__r4r@propertyrIrMrrTrYr\r`__static_attributes__ __classcell__r9s@r:r/r/.sq$ ## ####   !   r<r/ct^\rSrSrSrU4SjrU4SjrS SjrS SjrS Sjr SSjr SS jr SS jr S r U=r$)ra@ 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 -------- 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. Examples -------- >>> from scipy import signal >>> signal.lti(1, 2, 3, 4) StateSpaceContinuous( array([[1]]), array([[2]]), array([[3]]), array([[4]]), dt: None ) Construct the transfer function :math:`H(s) = \frac{5(s - 1)(s - 2)}{(s - 3)(s - 4)}`: >>> signal.lti([1, 2], [3, 4], 5) ZerosPolesGainContinuous( array([1, 2]), array([3, 4]), 5, dt: None ) Construct the transfer function :math:`H(s) = \frac{3s + 4}{1s + 2}`: >>> signal.lti([3, 4], [1, 2]) TransferFunctionContinuous( array([3., 4.]), array([1., 2.]), dt: None ) c&>U[Lay[U5nUS:Xa[R"[/UQ76$US:Xa[R"[/UQ76$US:Xa[ R"[ /UQ76$[ S5e[TU] U5$)/Create an instance of the appropriate subclass.zF`system` needs to be an instance of `lti` or have 2, 3 or 4 arguments.)rlenTransferFunctionContinuousr4ZerosPolesGainContinuousStateSpaceContinuous ValueErrorr3)r6r7Nr9s r:r4 lti.__new__s #:F AAv199.91799a/77,7/577a+334H=5;==!"@AAws##r<c >[TU]"U6 gr>)r3r@)rDr7r9s r:r@ lti.__init__s &!r<c[XX#S9$)zU Return the impulse response of a continuous-time system. See `impulse` for details. X0Trv)r$rDr|r}rvs r:r$ lti.impulses ta--r<c[XX#S9$)zO Return the step response of a continuous-time system. See `step` for details. r{)r%r~s r:r%lti.steps D1**r<c[XX#S9$)zW Return the response of a continuous-time system to input `U`. See `lsim` for details. )r|)r#)rDUr}r|s r:output lti.outputs DQ&&r<c[XUS9$)a 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. Examples -------- >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> sys = signal.TransferFunction([1], [1, 1]) >>> w, mag, phase = sys.bode() >>> plt.figure() >>> plt.semilogx(w, mag) # Bode magnitude plot >>> plt.figure() >>> plt.semilogx(w, phase) # Bode phase plot >>> plt.show() wn)r&rDrrs r:r&lti.bodes,D##r<c[XUS9$)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. r)r'rs r:r' lti.freqrespsQ''r<c[S5e)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.)r2rDrImethodalphas r: to_discretelti.to_discretes"#23 3r<NNNNNdN'zohN)rbrcrdre__doc__r4r@r$r%rr&r'rrgrhris@r:rrs7FN$&".+'$0( 3 3r<rc^\rSrSrSrU4SjrU4Sjr\S5r\RS5rS Sjr S Sjr SS jr SS jr SS jrS rU=r$)ri+a 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 -------- 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]``). .. versionadded:: 0.18.0 Examples -------- >>> from scipy import signal >>> signal.dlti(1, 2, 3, 4) StateSpaceDiscrete( array([[1]]), array([[2]]), array([[3]]), array([[4]]), dt: True ) >>> signal.dlti(1, 2, 3, 4, dt=0.1) StateSpaceDiscrete( array([[1]]), array([[2]]), array([[3]]), array([[4]]), dt: 0.1 ) Construct the transfer function :math:`H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)}` with a sampling time of 0.1 seconds: >>> signal.dlti([1, 2], [3, 4], 5, dt=0.1) ZerosPolesGainDiscrete( array([1, 2]), array([3, 4]), 5, dt: 0.1 ) Construct the transfer function :math:`H(z) = \frac{3z + 4}{1z + 2}` with a sampling time of 0.1 seconds: >>> signal.dlti([3, 4], [1, 2], dt=0.1) TransferFunctionDiscrete( array([3., 4.]), array([1., 2.]), dt: 0.1 ) c8>U[La[U5nUS:Xa[R"[/UQ70UD6$US:Xa[R"[/UQ70UD6$US:Xa[ R"[ /UQ70UD6$[ S5e[TU] U5$)rmrnrorpzG`system` needs to be an instance of `dlti` or have 2, 3 or 4 arguments.)rrqTransferFunctionDiscreter4ZerosPolesGainDiscreteStateSpaceDiscreterur3)r6r7r8rvr9s r:r4 dlti.__new__s $;F AAv/77,A/5A9?AAa-556LI7=IAGIIa)112DURSS5n[TU]"U0UD6 X0lg)r?rITN)popr3r@rI)rDr7r8rIr9s r:r@ dlti.__init__s, ZZd # &+F+r<cUR$)z'Return the sampling time of the system.rGrHs r:rIdlti.dtrKr<cXlgrrG)rDrIs r:rIrsr<c[XX#S9$)z] Return the impulse response of the discrete-time `dlti` system. See `dimpulse` for details. x0tr)r+rDrrrs r:r$ dlti.impulses q..r<c[XX#S9$)zW Return the step response of the discrete-time `dlti` system. See `dstep` for details. r)r*rs r:r% dlti.steps TA++r<c[XX#S9$)zX Return the response of the discrete-time system to input `u`. See `dlsim` for details. )r)r))rDurrs r:r dlti.outputs Ta''r<c[XUS9$)a{ Calculate Bode magnitude and phase data of a discrete-time system. Returns a 3-tuple containing arrays of frequencies [rad/s], magnitude [dB] and phase [deg]. See `dbode` for details. Examples -------- >>> from scipy import signal >>> import matplotlib.pyplot as plt Construct the transfer function :math:`H(z) = \frac{1}{z^2 + 2z + 3}` with sampling time 0.5s: >>> sys = signal.TransferFunction([1], [1, 2, 3], dt=0.5) Equivalent: signal.dbode(sys) >>> w, mag, phase = sys.bode() >>> plt.figure() >>> plt.semilogx(w, mag) # Bode magnitude plot >>> plt.figure() >>> plt.semilogx(w, phase) # Bode phase plot >>> plt.show() r)r-rs r:r& dlti.bodes8T!$$r<c[XX#S9$)z Calculate the frequency response of a discrete-time system. Returns a 2-tuple containing arrays of frequencies [rad/s] and complex magnitude. See `dfreqresp` for details. )rrwhole)r,)rDrrrs r:r' dlti.freqrespsa55r<)rCrIrrrNrF)rbrcrdrerr4r@rfrIsetterr$r%rr&r'rgrhris@r:rr+s^Wp$& YY/,(%< 6 6r<rc^\rSrSrSrU4SjrU4SjrSr\S5r \ RS5r \S5r \ RS 5r S r S r S rS r\S5r\S5rSrU=r$)r iaV Linear Time Invariant system class in transfer function form. Represents the system as the continuous-time transfer function :math:`H(s)=\sum_{i=0}^N b[N-i] s^i / \sum_{j=0}^M a[M-j] s^j` or the discrete-time transfer function :math:`H(z)=\sum_{i=0}^N b[N-i] z^i / \sum_{j=0}^M a[M-j] z^j`, where :math:`b` are elements of the numerator `num`, :math:`a` are elements of the denominator `den`, and ``N == len(b) - 1``, ``M == len(a) - 1``. `TransferFunction` systems inherit additional functionality from the `lti`, respectively the `dlti` classes, depending on which system representation is used. Parameters ---------- *system: arguments The `TransferFunction` class can be instantiated with 1 or 2 arguments. The following gives the number of input arguments and their interpretation: * 1: `lti` or `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 2: array_like: (numerator, denominator) 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 -------- ZerosPolesGain, StateSpace, lti, dlti tf2ss, tf2zpk, tf2sos Notes ----- Changing the value of properties that are not part of the `TransferFunction` 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. 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`` or ``z^2 + 3z + 5`` would be represented as ``[1, 3, 5]``) Examples -------- Construct the transfer function :math:`H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1}`: >>> from scipy import signal >>> num = [1, 3, 3] >>> den = [1, 2, 1] >>> signal.TransferFunction(num, den) TransferFunctionContinuous( array([1., 3., 3.]), array([1., 2., 1.]), dt: None ) Construct the transfer function :math:`H(z) = \frac{z^2 + 3z + 3}{z^2 + 2z + 1}` with a sampling time of 0.1 seconds: >>> signal.TransferFunction(num, den, dt=0.1) TransferFunctionDiscrete( array([1., 3., 3.]), array([1., 2., 1.]), dt: 0.1 ) cD>[U5S:Xa+[US[5(aUSR5$U[LaNUR S5c[ R"[ /UQ70UD6$[R"[/UQ70UD6$[TU]U5$)z8Handle object conversion if input is an instance of lti.rrrI) rqrWr/r_r getrrr4rr3r5s r:r4TransferFunction.__new__6s v;!  6!96I J J!9??$ $ " "zz$'199. 077, ws##r<c>[US[5(ag[TU] "S0UD6 SUlSUl[ U6uUlUlg)z&Initialize the state space LTI system.rNr) rWr/r3r@_num_denr numdenrDr7r8r9s r:r@TransferFunction.__init__KsM fQi!4 5 5  "6"  &/$(r<c URRS[UR5S[UR5S[UR 5S3$)z7Return representation of the system's transfer function( , , dt:  ))r9rbreprrrrIrHs r:__repr__TransferFunction.__repr__YsR~~&&'sDHH~cDHH~=/ & r<cUR$)z+Numerator of the `TransferFunction` system.)rrHs r:rTransferFunction.numbyyr<c[U5Ul[URR5S:a$URRuUlUlgSUlSUlgNr)rrrqrshaperBrA)rDrs r:rrgsHsO  txx~~  "(, %DL$+DLDKr<cUR$)z-Denominator of the `TransferFunction` system.)rrHs r:rTransferFunction.denrrr<c$[U5Ulgr)rr)rDrs r:rrws sO r<cHURUlURUlg)z Copy the parameters of another `TransferFunction` object Parameters ---------- system : `TransferFunction` The `StateSpace` system that is to be copied N)rrrDr7s r:_copyTransferFunction._copy{s::::r<c.[R"U5$)z Return a copy of the current `TransferFunction` system. Returns ------- sys : instance of `TransferFunction` The current system (copy) copydeepcopyrHs r:r_TransferFunction.to_tf}}T""r<ch[[URUR50URD6$)z Convert system representation to `ZerosPolesGain`. Returns ------- sys : instance of `ZerosPolesGain` Zeros, poles, gain representation of the current system )r!rrrrMrHs r:rPTransferFunction.to_zpks.vdhh9/ $ / /r<ch[[URUR50URD6$z Convert system representation to `StateSpace`. Returns ------- sys : instance of `StateSpace` State space model of the current system )r"rrrrMrHs r:rXTransferFunction.to_sss.54884+ MM+ +r<c[U5[U5- nUS:a/[R"[R"U5U45nX4$US:a-[R"[R"U*5U45nX4$)a%Change a transfer function from the variable `z` to `z**-1`. Parameters ---------- num, den: 1d array_like Sequences representing the coefficients of the numerator and denominator polynomials, in order of descending degree of 'z'. That is, ``5z**2 + 3z + 2`` is presented as ``[5, 3, 2]``. Returns ------- num, den: 1d array_like Sequences representing the coefficients of the numerator and denominator polynomials, in order of ascending degree of 'z**-1'. That is, ``5 + 3 z**-1 + 2 z**-2`` is presented as ``[5, 3, 2]``. rrqnphstackrrrdiffs r: _z_to_zinvTransferFunction._z_to_zinvsn$3x#c(" !8))RXXd^S12CxAX))RXXte_c23Cxr<c[U5[U5- nUS:a/[R"U[R"U545nX4$US:a-[R"U[R"U*545nX4$)a%Change a transfer function from the variable `z` to `z**-1`. Parameters ---------- num, den: 1d array_like Sequences representing the coefficients of the numerator and denominator polynomials, in order of ascending degree of 'z**-1'. That is, ``5 + 3 z**-1 + 2 z**-2`` is presented as ``[5, 3, 2]``. Returns ------- num, den: 1d array_like Sequences representing the coefficients of the numerator and denominator polynomials, in order of descending degree of 'z'. That is, ``5z**2 + 3z + 2`` is presented as ``[5, 3, 2]``. rrrs r: _zinv_to_zTransferFunction._zinv_to_zsn$3x#c(" !8))S"((4.12CxAX))S"((D5/23Cxr<)rrrrArrB)rbrcrdrerr4r@rrfrrrrr_rPrX staticmethodrrrgrhris@r:r r sJV$* 0  ZZ ZZ$$  # / +0r<r c"\rSrSrSrSSjrSrg)rria Continuous-time Linear Time Invariant system in transfer function form. Represents the system as the transfer function :math:`H(s)=\sum_{i=0}^N b[N-i] s^i / \sum_{j=0}^M a[M-j] s^j`, where :math:`b` are elements of the numerator `num`, :math:`a` are elements of the denominator `den`, and ``N == len(b) - 1``, ``M == len(a) - 1``. Continuous-time `TransferFunction` systems inherit additional functionality from the `lti` class. Parameters ---------- *system: arguments The `TransferFunction` class can be instantiated with 1 or 2 arguments. The following gives the number of input arguments and their interpretation: * 1: `lti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 2: array_like: (numerator, denominator) See Also -------- ZerosPolesGain, StateSpace, lti tf2ss, tf2zpk, tf2sos Notes ----- Changing the value of properties that are not part of the `TransferFunction` 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. 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]``) Examples -------- Construct the transfer function :math:`H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1}`: >>> from scipy import signal >>> num = [1, 3, 3] >>> den = [1, 2, 1] >>> signal.TransferFunction(num, den) TransferFunctionContinuous( array([ 1., 3., 3.]), array([ 1., 2., 1.]), dt: None ) Nc ^[[URUR4UUUS9SSSU06$)z Returns the discretized `TransferFunction` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `StateSpace` rrNrI)r rrrrs r:r&TransferFunctionContinuous.to_discretesH $((/C/16<5:"<=@R"A'$& ' 'r<rrrbrcrdrerrrgrr<r:rrrrs 9v'r<rrc\rSrSrSrSrg)ri.a( Discrete-time Linear Time Invariant system in transfer function form. Represents the system as the transfer function :math:`H(z)=\sum_{i=0}^N b[N-i] z^i / \sum_{j=0}^M a[M-j] z^j`, where :math:`b` are elements of the numerator `num`, :math:`a` are elements of the denominator `den`, and ``N == len(b) - 1``, ``M == len(a) - 1``. Discrete-time `TransferFunction` systems inherit additional functionality from the `dlti` class. Parameters ---------- *system: arguments The `TransferFunction` class can be instantiated with 1 or 2 arguments. The following gives the number of input arguments and their interpretation: * 1: `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 2: array_like: (numerator, denominator) 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 -------- ZerosPolesGain, StateSpace, dlti tf2ss, tf2zpk, tf2sos Notes ----- Changing the value of properties that are not part of the `TransferFunction` system representation (such as the `A`, `B`, `C`, `D` state-space matrices) is very inefficient and may lead to numerical inaccuracies. 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]``). Examples -------- Construct the transfer function :math:`H(z) = \frac{z^2 + 3z + 3}{z^2 + 2z + 1}` with a sampling time of 0.5 seconds: >>> from scipy import signal >>> num = [1, 3, 3] >>> den = [1, 2, 1] >>> signal.TransferFunction(num, den, dt=0.5) TransferFunctionDiscrete( array([ 1., 3., 3.]), array([ 1., 2., 1.]), dt: 0.5 ) rNrbrcrdrerrgrr<r:rr.s <z r<rc^\rSrSrSrU4SjrU4SjrSr\S5r \ RS5r \S5r \ RS 5r \S 5r \ RS 5r S r S rSrSrSrU=r$)r!ioa Linear Time Invariant system class in zeros, poles, gain form. Represents the system as the continuous- or discrete-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`. `ZerosPolesGain` systems inherit additional functionality from the `lti`, respectively the `dlti` classes, depending on which system representation is used. 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` or `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 `None` (continuous-time). Must be specified as a keyword argument, for example, ``dt=0.1``. See Also -------- TransferFunction, StateSpace, lti, 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. 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 ) Construct the transfer function :math:`H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)}` with a sampling time of 0.1 seconds: >>> signal.ZerosPolesGain([1, 2], [3, 4], 5, dt=0.1) ZerosPolesGainDiscrete( array([1, 2]), array([3, 4]), 5, dt: 0.1 ) cD>[U5S:Xa+[US[5(aUSR5$U[LaNUR S5c[ R"[ /UQ70UD6$[R"[/UQ70UD6$[TU]U5$)z9Handle object conversion if input is an instance of `lti`rrrI) rqrWr/rPr!rrsr4rr3r5s r:r4ZerosPolesGain.__new__s v;!  6!96I J J!9##% % . zz$'/77, .55*ws##r<c>[US[5(ag[TU] "S0UD6 SUlSUlSUlUuUlUlUl g)z)Initialize the zeros, poles, gain system.rNr) rWr/r3r@_zeros_poles_gainrrTgainrs r:r@ZerosPolesGain.__init__sQ fQi!4 5 5  "6"   ,2) DJ r<c URRS[UR5S[UR5S[UR 5S[UR 5S3 $)z5Return representation of the `ZerosPolesGain` system.rrrr)r9rbrrrTrrIrHs r:rZerosPolesGain.__repr__sd~~&&'sDJJ DJJ DII =/  & r<cUR$)z%Zeros of the `ZerosPolesGain` system.)rrHs r:rZerosPolesGain.zeros{{r<c[U5Ul[URR5S:a$URRuUlUlgSUlSUlgr)rrrqrrrBrA)rDrs r:rrsM '  tzz 1 $(, (8(8 %DL$+DLDKr<cUR$)z%Poles of the `ZerosPolesGain` system.)rrHs r:rTZerosPolesGain.polesrr<c$[U5Ulgr)rr)rDrTs r:rTr s ' r<cUR$)z$Gain of the `ZerosPolesGain` system.rrHs r:rZerosPolesGain.gainszzr<cXlgrr)rDrs r:rrs r<cjURUlURUlURUlg)z Copy the parameters of another `ZerosPolesGain` system. Parameters ---------- system : instance of `ZerosPolesGain` The zeros, poles gain system that is to be copied N)rTrrrs r:rZerosPolesGain._copys%\\ \\ KK r<c~[[URURUR50UR D6$)z Convert system representation to `TransferFunction`. Returns ------- sys : instance of `TransferFunction` Transfer function of the current system )r rrrTrrMrHs r:r_ZerosPolesGain.to_tfs4  DJJ !J1"&--1 1r<c.[R"U5$)z Return a copy of the current 'ZerosPolesGain' system. Returns ------- sys : instance of `ZerosPolesGain` The current system (copy) rrHs r:rPZerosPolesGain.to_zpkrr<c~[[URURUR50UR D6$r)r"rrrTrrMrHs r:rXZerosPolesGain.to_ss+s46$**djj$))D+ MM+ +r<)rrrrrArBrTr)rbrcrdrerr4r@rrfrrrTrrr_rPrXrgrhris@r:r!r!osCH$, 3  \\ \\(( [[   1 # + +r<r!c"\rSrSrSrSSjrSrg)rsi9a 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 ) Nc t[[URURUR4UUUS9SSSU06$)z Returns the discretized `ZerosPolesGain` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `ZerosPolesGain` rNrrI)r!rrrTrrs r:r$ZerosPolesGainContinuous.to_discretemsM DJJ DII>"(!&(),-   r<rrrrr<r:rsrs9s 1fr<rsc\rSrSrSrSrg)riaT 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 -------- 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. 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 ) Construct the transfer function :math:`H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)}` with a sampling time of 0.1 seconds: >>> signal.ZerosPolesGain([1, 2], [3, 4], 5, dt=0.1) ZerosPolesGainDiscrete( array([1, 2]), array([3, 4]), 5, dt: 0.1 ) rNrrr<r:rrsAD r<rcd^\rSrSrSrSrSrU4SjrU4SjrSr Sr S r S r S r S rS rSrSrSr\S5r\R*S5r\S5r\R*S5r\S5r\R*S5r\S5r\R*S5rSrSrSrSrSrU=r$)r"iaR 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 -------- 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. Examples -------- >>> from scipy import signal >>> import numpy as np >>> a = np.array([[0, 1], [0, 0]]) >>> b = np.array([[0], [1]]) >>> c = np.array([[1, 0]]) >>> d = np.array([[0]]) >>> sys = signal.StateSpace(a, b, c, d) >>> print(sys) StateSpaceContinuous( array([[0, 1], [0, 0]]), array([[0], [1]]), array([[1, 0]]), array([[0]]), dt: None ) >>> sys.to_discrete(0.1) StateSpaceDiscrete( array([[1. , 0.1], [0. , 1. ]]), array([[0.005], [0.1 ]]), array([[1, 0]]), array([[0]]), dt: 0.1 ) >>> a = np.array([[1, 0.1], [0, 1]]) >>> b = np.array([[0.005], [0.1]]) >>> signal.StateSpace(a, b, c, d, dt=0.1) StateSpaceDiscrete( array([[1. , 0.1], [0. , 1. ]]), array([[0.005], [0.1 ]]), array([[1, 0]]), array([[0]]), dt: 0.1 ) gY@NcD>[U5S:Xa+[US[5(aUSR5$U[LaNUR S5c[ R"[ /UQ70UD6$[R"[/UQ70UD6$[TU]U5$)z4Create new StateSpace object and settle inheritance.rrrI) rqrWr/rXr"rrtr4rr3r5s r:r4StateSpace.__new__s v;!  6!96I J J!9??$ $ * zz$'+334HG5;G?EGG*112DE39E=CEEws##r<c>[US[5(ag[TU] "S0UD6 SUlSUlSUlSUl[U6uUl Ul Ul Ul g)z+Initialize the state space lti/dlti system.rNr) rWr/r3r@_A_B_C_DrABCDrs r:r@StateSpace.__init__1sc fQi!4 5 5  "6")7)@&r<c URRS[UR5S[UR5S[UR 5S[UR 5S[UR5S3 $)z1Return representation of the `StateSpace` system.rrrr)r9rbrr%r&r'r(rIrHs r:rStateSpace.__repr__Asn~~&&'sDFF|nCDFF|nCDFF|nCDFF|n=/  & r<c ~[U[[R[[ [R [45$r)rWr"rndarrayfloatcomplexnumberintrDothers r:_check_binop_otherStateSpace._check_binop_otherLs+%*bjj%"$))S"23 3r<c URU5(d[$[U[5(Ga[ U5[ U5La[$UR UR :wa [ S5eURRSnURRSn[R"[R"UR[R"URUR545[R"[X245UR4545n[R"[R"URUR 5UR45n[R"UR[R"UR UR545n[R"UR UR 5nOZURn[R"URU5nURn[R"UR U5n[R""UR$UR$UR$UR$5n[[R&"XHS9[R&"XXS9[R&"XhS9[R&"XxS940UR(D6$)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)r4NotImplementedrWr"typerI TypeErrorr%rrvstackrrr&r'rr( result_typer8rrM) rDr3n1n2abcd common_dtypes r:__mul__StateSpace.__mul__Ps&&u--! ! eZ ( (E{$t*,%%ww%((" NOOaBq!B 299dffbffTVVUWW.E%FG99eRHouww%?@BCA 266$&&%''2EGG<=A 466266$&&%''#:;>> import numpy as np >>> from scipy import signal >>> a = np.array([[0, 1], [0, 0]]) >>> b = np.array([[0], [1]]) >>> c = np.array([[1, 0]]) >>> d = np.array([[0]]) >>> sys = signal.StateSpace(a, b, c, d) >>> print(sys) StateSpaceContinuous( array([[0, 1], [0, 0]]), array([[0], [1]]), array([[1, 0]]), array([[0]]), dt: None ) Nc [[URURURUR 4UUUS9SSSU06$)z Returns the discretized `StateSpace` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `StateSpace` rNrrI)r"rr%r&r'r(rs r:r StateSpaceContinuous.to_discretesR=$&&$&&$&&$&&)I)+06/467:r;! ! !r<rrrrr<r:rtrtYs 6p!r<rtc\rSrSrSrSrg)ria- 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 -------- 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. Examples -------- >>> import numpy as np >>> from scipy import signal >>> a = np.array([[1, 0.1], [0, 1]]) >>> b = np.array([[0.005], [0.1]]) >>> c = np.array([[1, 0]]) >>> d = np.array([[0]]) >>> signal.StateSpace(a, b, c, d, dt=0.1) StateSpaceDiscrete( array([[ 1. , 0.1], [ 0. , 1. ]]), array([[ 0.005], [ 0.1 ]]), array([[1, 0]]), array([[0]]), dt: 0.1 ) rNrrr<r:rrs 9t r<rc  [U[5(aUR5nO6[U[5(a [ S5e[U6R5n[ U5n[ UR5S:wa [S5e[[RURURURUR45upgpURSn URSn UR n Uc[#XRR$5n[R&"X4URR$5n USS:XaX=S'OGUSS:a3[)U[*R,"[/U5US-55U S'O [S5eUSL=(dD [U[0[245=(a US:H=(d [R4"U5(+nU S:XaE[7XR8-5nU(dU[7XR8-5- nX/[7U 54$USUS- n[R:"[R<"U5U5(d [S5eU(ah[*R,"UR8U-5n[?SU 5HnU US- U-U U'M [7XR8-5nX/[7U 54$[ U5nUR@S:XaUSS2[RB4nURSU :wa [S 5eURSU :wa [S 5eU(d[RD"[RF"UU-UU-/5[R""XU -45/5n[*R,"UR85nUSU 2SU 24nUU S2SU 24n[?SU 5HnU US- U-UUS- U--U U'M GO&[RD"[RF"UU-UU-[R""X45/5[RF"[R""XU -45[RH"U 5/5[R""XS U --45/5n[*R,"UR85nUSU 2SU 24nUX-S2SU 24nUXU -2SU 24U- n[?SU 5H&nU US- U-UUS- U--UUU--U U'M( [7XR8-5[7XR8-5-nX/[7U 54$) 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]``). Examples -------- We'll use `lsim` to simulate an analog Bessel filter applied to a signal. >>> import numpy as np >>> from scipy.signal import bessel, lsim >>> import matplotlib.pyplot as plt Create a low-pass Bessel filter with a cutoff of 12 Hz. >>> b, a = bessel(N=5, Wn=2*np.pi*12, btype='lowpass', analog=True) Generate data to which the filter is applied. >>> t = np.linspace(0, 1.25, 500, endpoint=False) The input signal is the sum of three sinusoidal curves, with frequencies 4 Hz, 40 Hz, and 80 Hz. The filter should mostly eliminate the 40 Hz and 80 Hz components, leaving just the 4 Hz signal. >>> u = (np.cos(2*np.pi*4*t) + 0.6*np.sin(2*np.pi*40*t) + ... 0.5*np.cos(2*np.pi*80*t)) Simulate the filter with `lsim`. >>> tout, yout, xout = lsim((b, a), U=u, T=t) Plot the result. >>> plt.plot(t, u, 'r', alpha=0.5, linewidth=1, label='input') >>> plt.plot(tout, yout, 'k', linewidth=1.5, label='output') >>> plt.legend(loc='best', shadow=True, framealpha=1) >>> plt.grid(alpha=0.3) >>> plt.xlabel('t') >>> plt.show() In a second example, we simulate a double integrator ``y'' = u``, with a constant input ``u = 1``. We'll use the state space representation of the integrator. >>> from scipy.signal import lti >>> A = np.array([[0.0, 1.0], [0.0, 0.0]]) >>> B = np.array([[0.0], [1.0]]) >>> C = np.array([[1.0, 0.0]]) >>> D = 0.0 >>> system = lti(A, B, C, D) `t` and `u` define the time and input signal for the system to be simulated. >>> t = np.linspace(0, 5, num=50) >>> u = np.ones_like(t) Compute the simulation, and then plot `y`. As expected, the plot shows the curve ``y = 0.5*t**2``. >>> tout, y, x = lsim(system, u, t) >>> plt.plot(t, y) >>> plt.grid(alpha=0.3) >>> plt.xlabel('t') >>> plt.show() 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.rn)%rWrrYrAttributeErrorrrqrrumaprrr%r&r'r(sizerr8emptyrrexpmrr1r.anyrr}allcloserranger_newaxisr<ridentity)r7rr}r|interpsysr%r&r'r(n_statesn_inputsn_stepsxoutno_inputyoutrIexpAT_dtiMexpMTAdBdBd1Bd0s r:r#r#sX&#mmo FD ! !() )6l!!#1 A 177|q455RZZ#%%suu!=>JA!wwqzHwwqzHffG z 8UU[[ ) 88W' 5DtqyQ 1b&++ilQqT&9:;Q;<<T AU|,8bFF1I  !|tccz" GAG$ $D %% 1!B ;;rwwqz2 & &=>>;;qssRx(q'"A1Q3i(*DG#tccz" %% 1 Avv{ am wwqzW-. . wwqzXCDD  IIryy!b&!b&!12xxh+> ?@B C ACC  9H9ixi' ( 89ixi' (q'"A1Q3i"nq1v{2DG# IIryy!b&!b&"$((H+?"@"BCyy"((H6I+J"K"$++h"7"9:xxa(l+B CD F G  ACC  9H9ixi' (H%&  12H00)8);>! D CT OACx  qBa"fa A Hr<c[U[5(aUR5nO6[U[5(a [ S5e[U6R5nUc[ UR 5nO[ UR U-5nUcSnUc[URU5nO [U5n[USX%SS9upgnX'4$)aImpulse response of continuous-time system. Parameters ---------- system : an instance of the LTI class or a tuple of array_like 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) 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 ------- T : ndarray A 1-D array of time points. yout : ndarray A 1-D array containing the impulse response of the system (except for singularities at zero). 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]``). Examples -------- Compute the impulse response of a second order system with a repeated root: ``x''(t) + 2*x'(t) + x(t) = u(t)`` >>> from scipy import signal >>> system = ([1.0], [1.0, 2.0, 1.0]) >>> t, y = signal.impulse(system) >>> import matplotlib.pyplot as plt >>> plt.plot(t, y) z6impulse can only be used with continuous-time systems.rrF)r) rWrrYrrrr&rr%rr#)r7r|r}rvrX_hs r:r$r$s`&#mmo FD ! !() )6l!!# z CEEN CEEBJ y y #CEE1 - AJ3A/GA! 4Kr<c[U[5(aUR5nO6[U[5(a [ S5e[U6R5nUcSnUc[ UR U5nO [U5n[URUR R5n[XEX!SS9nUSUS4$)aStep response of continuous-time system. Parameters ---------- system : an instance of the LTI class or a tuple of array_like 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) X0 : array_like, optional Initial state-vector (default is zero). T : array_like, optional Time points (computed if not given). N : int, optional Number of time points to compute if `T` is not given. Returns ------- T : 1D ndarray Output time points. yout : 1D ndarray Step response of system. 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]``). Examples -------- >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> lti = signal.lti([1.0], [1.0, 1.0]) >>> t, y = signal.step(lti) >>> plt.plot(t, y) >>> plt.xlabel('Time [s]') >>> plt.ylabel('Amplitude') >>> plt.title('Step response for 1. Order Lowpass') >>> plt.grid() z3step can only be used with continuous-time systems.rF)r|rrr) rWrrYrrrr%rrrr8r#)r7r|r}rvrrrs r:r%r%sb&#mmo FD ! !() )6l!!#y y #CEE1 - AJ QWWceekk"A  /D 7DG r<c [XUS9upS[R"[U55-n[R"[R "UR UR55S-[R- nXU4$)a Calculate Bode magnitude and phase data of a continuous-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 `lti`) * 2 (num, den) * 3 (zeros, poles, gain) * 4 (A, B, C, D) w : array_like, optional Array of frequencies (in rad/s). 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/s] mag : 1D ndarray Magnitude array [dB] phase : 1D ndarray Phase array [deg] 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]``). .. versionadded:: 0.11.0 Examples -------- >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> sys = signal.TransferFunction([1], [1, 1]) >>> w, mag, phase = signal.bode(sys) >>> plt.figure() >>> plt.semilogx(w, mag) # Bode magnitude plot >>> plt.figure() >>> plt.semilogx(w, phase) # Bode phase plot >>> plt.show() r4@gf@) r'rlog10runwraparctan2imagrpi)r7rrymagphases r:r&r&`scp F1 %DA #a&! !C IIbjj0 1E 9BEE AE 5=r<ct[U[5(a/[U[[45(aUnOGUR 5nO6[U[ 5(a [ S5e[U6R 5nURS:wdURS:wa [S5eUbUnOUn[U[5(a2[URR5URUS9upX4$[U[5(a,[URUR UR"US9upUW4$)aCalculate the frequency response of a continuous-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 `lti`) * 2 (num, den) * 3 (zeros, poles, gain) * 4 (A, B, C, D) w : array_like, optional Array of frequencies (in rad/s). 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/s] H : 1D ndarray Array of complex magnitude values 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]``). Examples -------- Generating the Nyquist plot of a transfer function >>> from scipy import signal >>> import matplotlib.pyplot as plt Construct the transfer function :math:`H(s) = \frac{5}{(s-1)^3}`: >>> s1 = signal.ZerosPolesGain([], [1, 1, 1], [5]) >>> w, H = signal.freqresp(s1) >>> plt.figure() >>> plt.plot(H.real, H.imag, "b") >>> plt.plot(H.real, -H.imag, "r") >>> plt.show() z7freqresp can only be used with continuous-time systems.rz@freqresp() requires a SISO (single input, single output) system.)worN)rWrr r!r\rrrArBrur rravelrr rrTr)r7rrrrrs r:r'r'sl&# f/@ A AC.."C FD ! !() )6l""$ zzQ#++*+, , }#'((SWW]]_cggD9 4K C ( (CIIsxxdC a4Kr<c\rSrSrSrSrg)Bunchic :URRU5 gr)__dict__update)rDkwdss r:r@Bunch.__init__s T"r<rN)rbrcrdrer@rgrr<r:rrs#r<rc[R"U5nURS:a [S5e[ U5nURS:a [S5eURS:a [S5eUR SUR S:wa [S5e[ U5UR S:a&[SUR S[ U54-5e[ U5UR S:a&[S [ U5UR S4-5e[RRU5nUHn[Xr:H5U:dM[S 5e [nUS ;a [S 5eUS :Xa5[n[[R"U55(d [S5eUS:a [S5eUS:a [S5eX4$)z Check the poles come in complex conjugate 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.rnzA 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'rz'Complex poles are not supported by KNV0z#maxiter must be at least equal to 1zrtol can not be greater than 1)rrr_ru_order_complex_polesrrqr matrix_ranksum_YT_loop _KNV0_loopallisreal) r%r&rTrrtolmaxiterrp update_loops r: _valid_inputsrs JJu E zzA~9::  'Evvz788vvz677wwqzQWWQZ+,, 5zAGGAJM''!*c%j123 3 5zAGGAJJe*aggaj123 3 a A  qz?Q 78 8 K ]"KLL  299U#$$FG G{>?? ax9::  r<c[R"U[R"U55n/n[R"U[R"U5S:5HFn[R"U5U;dMUR U[R"U545 MH [R "X45nURS[U5:wa [S5eU$)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) rsortrrconjextendrrrqru)rT ordered_polesim_polesrs r:rr/ sGGE"))E"234MH WWU2775>A-. / 771:  OOQ O ,0II}78M {{1~]++HII r<cX[R"X#SS9n[USS9upg[R"XXR5n[R"XSS2S45n [R "U S5(d+U [R RU 5- n XSS2U4'gg)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 raxisfullmodeNrr)rdeletes_qrrr}rrnorm) r&ker_poletransfer_matrixjrTtransfer_matrix_not_jQR mat_ker_pjyjxjs r:_KNV0rC sIIoqA %F 3DA X[]]3J  aeH %B ;;r1    r" " "1 r<c zUSS2S[R4nUSS2S[R4n[R"[R"XR[R"XVR5[R"XeR5- 5X5n[RR U5upn URSS2SS2[R4upU SS2SS2[R4up[R "USS2U[R4USS2U[R445n[R"U SU S5(dK[R"XU 5n[R"XU 5n[R "UU45nO[R "[R"X[R"XR545[R"[R"XR5X4545n[R "[R"X45[R"X4545n[R"UU5n[R"[R"UUR5U5n[R"US5(d[R"S5U-[RRU5- nUSUSS2U4RS2S4USS2U4'UUSS2U4RSS2S4USS2U4'gUSUSS2U4RS2S4USS2U4'UUSS2U4RSS2S4USS2U4'g)zE Applies algorithm from YT section 6.1 page 19 related to real pairs Nrrnrr) rrrr}rsvdr<rrrrsqrtr)rrrrrrvmumsmvmmu1mu2nu1nu2&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_realrr s8 !R A !R A rvvhkmmRVVAss^ q##&! &Aq!JBBttBQB2::%&HC"1"a#$HC.0YY Aq"**, - Aq"**, -8/.0* ;;r!ube $ $66(+s3 S1$4n#EFii " 8;+-88HK4E4E+F+H!I " 288HK4E4E+F4>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> A = np.array([[ 1.380, -0.2077, 6.715, -5.676 ], ... [-0.5814, -4.290, 0, 0.6750 ], ... [ 1.067, 4.273, -6.654, 5.893 ], ... [ 0.0480, 4.273, 1.343, -2.104 ]]) >>> B = np.array([[ 0, 5.679 ], ... [ 1.136, 1.136 ], ... [ 0, 0, ], ... [-3.146, 0 ]]) >>> P = np.array([-0.2, -0.5, -5.0566, -8.6659]) Now compute K with KNV method 0, with the default YT method and with the YT method while forcing 100 iterations of the algorithm and print some results after each call. >>> fsf1 = signal.place_poles(A, B, P, method='KNV0') >>> fsf1.gain_matrix array([[ 0.20071427, -0.96665799, 0.24066128, -0.10279785], [ 0.50587268, 0.57779091, 0.51795763, -0.41991442]]) >>> fsf2 = signal.place_poles(A, B, P) # uses YT method >>> fsf2.computed_poles array([-8.6659, -5.0566, -0.5 , -0.2 ]) >>> fsf3 = signal.place_poles(A, B, P, rtol=-1, maxiter=100) >>> fsf3.X array([[ 0.52072442+0.j, -0.08409372+0.j, -0.56847937+0.j, 0.74823657+0.j], [-0.04977751+0.j, -0.80872954+0.j, 0.13566234+0.j, -0.29322906+0.j], [-0.82266932+0.j, -0.19168026+0.j, -0.56348322+0.j, -0.43815060+0.j], [ 0.22267347+0.j, 0.54967577+0.j, -0.58387806+0.j, -0.40271926+0.j]]) The absolute value of the determinant of X is a good indicator to check the robustness of the results, both ``'KNV0'`` and ``'YT'`` aim at maximizing it. Below a comparison of the robustness of the results above: >>> abs(np.linalg.det(fsf1.X)) < abs(np.linalg.det(fsf2.X)) True >>> abs(np.linalg.det(fsf2.X)) < abs(np.linalg.det(fsf3.X)) True Now a simple example for complex poles: >>> A = np.array([[ 0, 7/3., 0, 0 ], ... [ 0, 0, 0, 7/9. ], ... [ 0, 0, 0, 0 ], ... [ 0, 0, 0, 0 ]]) >>> B = np.array([[ 0, 0 ], ... [ 0, 0 ], ... [ 1, 0 ], ... [ 0, 1 ]]) >>> P = np.array([-3, -1, -2-1j, -2+1j]) / 3. >>> fsf = signal.place_poles(A, B, P, method='YT') We can plot the desired and computed poles in the complex plane: >>> t = np.linspace(0, 2*np.pi, 401) >>> plt.plot(np.cos(t), np.sin(t), 'k--') # unit circle >>> plt.plot(fsf.requested_poles.real, fsf.requested_poles.imag, ... 'wo', label='Desired') >>> plt.plot(fsf.computed_poles.real, fsf.computed_poles.imag, 'bx', ... label='Placed') >>> plt.grid() >>> plt.axis('image') >>> plt.axis([-1.1, 1.1, -1.1, 1.1]) >>> plt.legend(bbox_to_anchor=(1.05, 1), loc=2, numpoints=1) rrrNrr)rcondFrTzSConvergence was not reached after maxiter iterations. You asked for a tolerance of z , we got .rn) stacklevelrzfThe poles you've chosen can't be placed. Check the controllability matrix and try another set of poles)(rrrrrrrrrrlstsqeyenanrrr}rrrrrr warningswarnastyper/rsolvediag LinAlgErrorrur gain_matrixrrcomputed_polesrequested_polesrrnb_iter)"r%r&rTrrrrrr.rzrankBu0u1 diag_polesidxrr+rrskip_conjugater pole_space_jrr ker_pole_jtransfer_matrix_jrerr_msgrelimgrefull_state_feedbacks" r:r(r({ s)j'qUDJKHG  DA II ! !! $E 1fuf9B 1ef9B &5&!) A wwqzU(XXagg& KKN" A#%771:JCx  ! }*,''!* A:&+-771: q5#a%<()+ q5#:&q 1HCKKN"iiooaARo@C &&,66&& qwwqz"A!&66"$$(266!''!*3E*E(EFHHL 62DAq1l003445J$!#z :1bjj= I !2!#0A!B"C  %(##$&IIrww7H/I/1ww7H/I/K%L!Z 89"& +Av"3"$))_>O,P"Qe#h 19&1(O27G'K #D(D1H44868*AO g!4 *009KKN1$$ %*%%%af-224%aQh/+.bf*3',/3J3q5)q 1HCKKN1$$ <  1 1266"''%.:I:K:K4MNNOa ))//!RVVBDD!A#->?K,K''+&K'&1#)= a"&&K001!4* &+0'+'") )yy$$ <45:; < >> import numpy as np >>> from scipy import signal >>> tf = ([1.0,], [1.0, -1.0], 1.0) >>> t_in = [0.0, 1.0, 2.0, 3.0] >>> u = np.asarray([0.0, 0.0, 1.0, 1.0]) >>> t_out, y = signal.dlsim(tf, u, t=t_in) >>> y.T array([[ 0., 0., 0., 1.]]) z7dlsim can only be used with discrete-time dlti systems.NrrIrrr)r)k)rWrrrr"rYrrr_rQr}rqrIr1floorrr%rr'rrrrrrr&r() r7rrr is_ss_input out_samplesstoptimerrtoutu_dtrs r:r)r) sr&#() )  % %vcr{2vbz2VZ0K ]]_F aAvv{ MM!   y!f !Ovyy0R5"((8ii#789A=  88[((.."34 5D 88[((.."34 5D ;;sH 6D zXXvxx~~a023QT ZZ^QT  y qww<1 !RZZ- A!!!,T21kAo &vxxd4vxxd45qS!V ffVXXtqDz2ffVXXtqDz23T '!ffVXXtM14D/EF ffVXXtM14D/EFGDQ 4zr<cD[U[5(aUR5nO?[U[5(a [ S5e[USSSUS06R5nUcSnUc$[ R "SX0R-USS9nO[ R"U5nSn[SUR5HZn[ R"URSUR45nS USU4'[XX!S 9nUcUS 4nOXGS 4-nUSnM\ WU4$) 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 -------- impulse, dstep, dlsim, cont2discrete Examples -------- >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> butter = signal.dlti(*signal.butter(3, 0.5)) >>> t, y = signal.dimpulse(butter, n=25) >>> plt.step(t, np.squeeze(y)) >>> plt.grid() >>> plt.xlabel('n [samples]') >>> plt.ylabel('Amplitude') z:dimpulse can only be used with discrete-time dlti systems.NrrIrrFendpointrrrr)rWrrYrrrrrIrrrArrr) r7rrrrrr one_outputrDs r:r+r+N s#d&$ FC -. .vcr{2vbz299; y  y KK1yy=!e < JJqM D 1fmm $ HHaggaj&--0 1!Q$61 <qM#Da=**D!}% :r<c[U[5(aUR5nO?[U[5(a [ S5e[USSSUS06R5nUcSnUc$[ R "SX0R-USS9nO[ R"U5nSn[SUR5H~n[ R"URSUR45n[ R"URS45USS2U4'[XX!S 9nUcUS 4nOXGS 4-nUSnM WU4$) 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 -------- step, dimpulse, dlsim, cont2discrete Examples -------- >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> butter = signal.dlti(*signal.butter(3, 0.5)) >>> t, y = signal.dstep(butter, n=25) >>> plt.step(t, np.squeeze(y)) >>> plt.grid() >>> plt.xlabel('n [samples]') >>> plt.ylabel('Amplitude') z7dstep can only be used with discrete-time dlti systems.NrrIrrFrGrIr)rWrrYrrrrrIrrrArrrr)rJs r:r*r* s6b&$ FC () )vcr{2vbz299; y  y KK1yy=!e < JJqM D 1fmm $ HHaggaj&--0 1''1771:-(!Q$61 <qM#Da=**D!}% :r<c[U[5(d1[U[5(a [S5e[USSSUS06n[U[5(aUR 5n[U[ [45(d [S5eURS:wdURS:wa [S5eUbUnOUn[U[ 5(aI[ RURR5UR5upV[XVXCS9upX4$[U[5(a-[!UR"UR$UR&UUS9upUW4$) aE 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 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]``). .. versionadded:: 0.18.0 Examples -------- Generating the Nyquist plot of a transfer function >>> from scipy import signal >>> import matplotlib.pyplot as plt Construct the transfer function :math:`H(z) = \frac{1}{z^2 + 2z + 3}` with a sampling time of 0.05 seconds: >>> sys = signal.TransferFunction([1], [1, 2, 3], dt=0.05) >>> w, H = signal.dfreqresp(sys) >>> plt.figure() >>> plt.plot(H.real, H.imag, "b") >>> plt.plot(H.real, -H.imag, "r") >>> plt.show() z6dfreqresp can only be used with discrete-time systems.NrrIzUnknown system typerz?dfreqresp requires a SISO (single input, single output) system.)rr)rWrrrr"r`r r!rurArBrrrrr r rrTr)r7rrrrrrrs r:r,r, sF@ fd # # fc " " ":; ;vcr{2vbz2&*%% f/@ A A.// }}V^^q0+, , }&*++$..vzz/?/?/A6::NSD6 4K FN + +v||V[[t$& a4Kr<c4[XUS9up[U[5(a URnOUSnS[R "[ U55-n[R"[R"[R"U555nX- XV4$)u Calculate Bode magnitude and phase data of a discrete-time system. Parameters ---------- system : An instance of the LTI class `dlti` or a tuple describing the system. The number of elements in the tuple determine the interpretation, i.e.: 1. ``(sys_dlti)``: Instance of LTI class `dlti`. Note that derived instances, such as instances of `TransferFunction`, `ZerosPolesGain`, or `StateSpace`, are allowed as well. 2. ``(num, den, dt)``: Rational polynomial as described in `TransferFunction`. The coefficients of the polynomials should be specified in descending exponent order, e.g., z² + 3z + 5 would be represented as ``[1, 3, 5]``. 3. ``(zeros, poles, gain, dt)``: Zeros, poles, gain form as described in `ZerosPolesGain`. 4. ``(A, B, C, D, dt)``: State-space form as described in `StateSpace`. w : array_like, optional Array of frequencies normalized to the Nyquist frequency being π, i.e., having unit radiant / 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 Array of frequencies normalized to the Nyquist frequency being ``np.pi/dt`` with ``dt`` being the sampling interval of the `system` parameter. The unit is rad/s assuming ``dt`` is in seconds. mag : 1D ndarray Magnitude array in dB phase : 1D ndarray Phase array in degrees Notes ----- This function is a convenience wrapper around `dfreqresp` for extracting magnitude and phase from the calculated complex-valued amplitude of the frequency response. .. versionadded:: 0.18.0 See Also -------- dfreqresp, dlti, TransferFunction, ZerosPolesGain, StateSpace Examples -------- The following example shows how to create a Bode plot of a 5-th order Butterworth lowpass filter with a corner frequency of 100 Hz: >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from scipy import signal ... >>> T = 1e-4 # sampling interval in s >>> f_c, o = 1e2, 5 # corner frequency in Hz (i.e., -3 dB value) and filter order >>> bb, aa = signal.butter(o, f_c, 'lowpass', fs=1/T) ... >>> w, mag, phase = signal.dbode((bb, aa, T)) >>> w /= 2*np.pi # convert unit of frequency into Hertz ... >>> fg, (ax0, ax1) = plt.subplots(2, 1, sharex='all', figsize=(5, 4), ... tight_layout=True) >>> ax0.set_title("Bode Plot of Butterworth Lowpass Filter " + ... rf"($f_c={f_c:g}\,$Hz, order={o})") >>> ax0.set_ylabel(r"Magnitude in dB") >>> ax1.set(ylabel=r"Phase in Degrees", ... xlabel="Frequency $f$ in Hertz", xlim=(w[1], w[-1])) >>> ax0.semilogx(w, mag, 'C0-', label=r"$20\,\log_{10}|G(f)|$") # Magnitude plot >>> ax1.semilogx(w, phase, 'C1-', label=r"$\angle G(f)$") # Phase plot ... >>> for ax_ in (ax0, ax1): ... ax_.axvline(f_c, color='m', alpha=0.25, label=rf"${f_c=:g}\,$Hz") ... ax_.grid(which='both', axis='x') # plot major & minor vertical grid lines ... ax_.grid(which='major', axis='y') ... ax_.legend() >>> plt.show() rrr) r,rWrrIrrrrad2degrangle)r7rrrrIrrs r:r-r-_ sul VA &DA&$ YY BZ #a&! !C JJryy!- .E 63 r<)NTrrr)rgMbP?)NNr)Frr% scipy.linalgrrscipyrscipy.interpolater_filter_designrrr r r r r _lti_conversionrrrrrrrnumpyrrrrrrrrrrr__all__r/rrr rrrr!rsrr"rtrr#rr$r%r&r'rrrrrrrrr(r)r+r*r,r-rr<r:rYs* $0'''AAA333  ! S S ld3 d3N|6 |6~t*tnJ'!13J'Z> /> BG+(G+TC~sCLC ^TC LQ#$Q#h G!:sG!T; T; |T"n >CL@F=@Rn## 0f(!#^>B0;fx"v"4\~ qhTnSlaH`r<