a BCCf@sNdZddlZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZddlmZmZmZmZmZmZmZddlZddlZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#ddl$Z$gd Z%Gd d d Z&Gd dde&Z'Gddde&Z(Gddde&Z)Gddde)e'Z*Gddde)e(Z+Gddde&Z,Gddde,e'Z-Gddde,e(Z.Gddde&Z/Gdd d e/e'Z0Gd!d"d"e/e(Z1dRd$d%Z2d&d'Z3dSd(d)Z4dTd*d+Z5dUd-d.Z6dVd0d1Z7Gd2d3d3Z8d4d5Z9d6d7Z:d8d9Z;d:d;Zd?Z>d@dAZ?dWdEdFZ@dXdGdHZAdYdIdJZBdZdKdLZCd[dNdOZDd\dPdQZEdS)]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 dfreqrespdbodecspeZdZfddZfddZeddZeddZed d Zed d Z d dZ ddZ ddZ Z S)LinearTimeInvariantcs|turtdt|S)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__P/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/signal/_ltisys.pyr00szLinearTimeInvariant.__new__cs td|_d|_d|_dSg Initialize the `lti` baseclass. The heavy lifting is done by the subclasses. N)r/__init__inputsoutputs_dtselfr5r7r8r;8s zLinearTimeInvariant.__init__cCs|jS)zAReturn the sampling time of the system, `None` for `lti` systems.r>r?r7r7r8dtDszLinearTimeInvariant.dtcCs|jduriSd|jiSdS)NrB)rBr?r7r7r8_dt_dictIs zLinearTimeInvariant._dt_dictcCs |jS)zZeros of the system.)to_zpkrr?r7r7r8rPszLinearTimeInvariant.zeroscCs |jS)zPoles of the system.)rDpolesr?r7r7r8rEUszLinearTimeInvariant.polescCst|tr|S|SdS)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. N) isinstancer!to_ssr?r7r7r8_as_ssZs zLinearTimeInvariant._as_sscCst|tr|S|SdS)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. N)rFr rDr?r7r7r8_as_zpkhs zLinearTimeInvariant._as_zpkcCst|tr|S|SdS)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. N)rFrto_tfr?r7r7r8_as_tfvs zLinearTimeInvariant._as_tf)__name__ __module__ __qualname__r0r;propertyrBrCrrErHrIrK __classcell__r7r7r5r8r-/s      r-csheZdZdZfddZfddZdddZdd d Zdd d ZdddZ dddZ dddZ Z S)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 ) csr|turft|}|dkr*tjtg|RS|dkrDtjtg|RS|dkr^tjtg|RStdt|S)/Create an instance of the appropriate subclass.zF`system` needs to be an instance of `lti` or have 2, 3 or 4 arguments.)rlenTransferFunctionContinuousr0ZerosPolesGainContinuousStateSpaceContinuous ValueErrorr/)r2r3Nr5r7r8r0s(z lti.__new__cstj|dSr9)r/r;r@r3r5r7r8r;sz lti.__init__NcCst||||dS)zm Return the impulse response of a continuous-time system. See `impulse` for details. X0TrZ)r#r@r]r^rZr7r7r8r#sz lti.impulsecCst||||dS)zg Return the step response of a continuous-time system. See `step` for details. r\)r$r_r7r7r8r$szlti.stepcCst||||dS)zo Return the response of a continuous-time system to input `U`. See `lsim` for details. )r])r")r@Ur^r]r7r7r8outputsz lti.outputdcCst|||dS)ai 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%r@rdrer7r7r8r%szlti.bode'cCst|||dS)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. rc)r&rfr7r7r8r&sz lti.freqrespzohcCs tddS)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.N)r.r@rBmethodalphar7r7r8 to_discretes zlti.to_discrete)NNN)NNN)N)Nrb)Nrg)rhN) rLrMrN__doc__r0r;r#r$rar%r&rlrPr7r7r5r8rsG       rcsxeZdZdZfddZfddZeddZejddZdd d Z dd d Z dddZ dddZ dddZ ZS)ra 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 ) cs|turxt|}|dkr0tjtg|Ri|S|dkrPtjtg|Ri|S|dkrptjtg|Ri|Stdt|S)rQrRrSrTzG`system` needs to be an instance of `dlti` or have 2, 3 or 4 arguments.)rrUTransferFunctionDiscreter0ZerosPolesGainDiscreteStateSpaceDiscreterYr/)r2r3r4rZr5r7r8r0s,z dlti.__new__cs(|dd}tj|i|||_dS)r:rBTN)popr/r;rB)r@r3r4rBr5r7r8r;s z dlti.__init__cCs|jS)z'Return the sampling time of the system.rAr?r7r7r8rBszdlti.dtcCs ||_dSNrA)r@rBr7r7r8rBsNcCst||||dS)zu Return the impulse response of the discrete-time `dlti` system. See `dimpulse` for details. x0tre)r*r@rtrurer7r7r8r#sz dlti.impulsecCst||||dS)zo Return the step response of the discrete-time `dlti` system. See `dstep` for details. rs)r)rvr7r7r8r$sz dlti.stepcCst||||dS)zp Return the response of the discrete-time system to input `u`. See `dlsim` for details. )rt)r()r@ururtr7r7r8rasz dlti.outputrbcCst|||dS)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() rc)r,rfr7r7r8r%sz dlti.bodergFcCst||||dS)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. )rdrewhole)r+)r@rdrerxr7r7r8r&s z dlti.freqresp)NNN)NNN)N)Nrb)NrgF)rLrMrNrmr0r;rOrBsetterr#r$rar%r&rPr7r7r5r8r,sX        rcseZdZdZfddZfddZddZedd Zej d d Zed d Z e j d d Z ddZ ddZ ddZ ddZeddZeddZZS)raJ 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 ) csxt|dkr&t|dtr&|dS|turl|ddurTtjtg|Ri|Stjtg|Ri|St |S)z8Handle object conversion if input is an instance of lti.rrrBN) rUrFr-rJrgetrVr0rnr/r1r5r7r8r07s& zTransferFunction.__new__csDt|dtrdStjfi|d|_d|_t|\|_|_dS)z&Initialize the state space LTI system.rN) rFr-r/r;_num_denrnumdenr@r3r4r5r7r8r;Ls zTransferFunction.__init__cCs&d|jjt|jt|jt|jS)z7Return representation of the system's transfer functionz{}( {}, {}, dt: {} ))formatr6rLreprr}r~rBr?r7r7r8__repr__Zs zTransferFunction.__repr__cCs|jS)z+Numerator of the `TransferFunction` system.)r{r?r7r7r8r}cszTransferFunction.numcCs<t||_t|jjdkr,|jj\|_|_n d|_d|_dSNr)rr{rUr}shaper=r<)r@r}r7r7r8r}hs  cCs|jS)z-Denominator of the `TransferFunction` system.)r|r?r7r7r8r~sszTransferFunction.dencCst||_dSrr)rr|)r@r~r7r7r8r~xscCs|j|_|j|_dS)z Copy the parameters of another `TransferFunction` object Parameters ---------- system : `TransferFunction` The `StateSpace` system that is to be copied N)r}r~r[r7r7r8_copy|s zTransferFunction._copycCs t|S)z Return a copy of the current `TransferFunction` system. Returns ------- sys : instance of `TransferFunction` The current system (copy) copydeepcopyr?r7r7r8rJs zTransferFunction.to_tfcCstt|j|ji|jS)z Convert system representation to `ZerosPolesGain`. Returns ------- sys : instance of `ZerosPolesGain` Zeros, poles, gain representation of the current system )r rr}r~rCr?r7r7r8rDs zTransferFunction.to_zpkcCstt|j|ji|jSz Convert system representation to `StateSpace`. Returns ------- sys : instance of `StateSpace` State space model of the current system )r!r r}r~rCr?r7r7r8rGs zTransferFunction.to_sscCsTt|t|}|dkr.tt||f}n|dkrLtt| |f}||fS)aChange 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]``. rrUnphstackrr}r~diffr7r7r8 _z_to_zinvs zTransferFunction._z_to_zinvcCsTt|t|}|dkr.t|t|f}n|dkrLt|t| f}||fS)aChange 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]``. rrrr7r7r8 _zinv_to_zs zTransferFunction._zinv_to_z)rLrMrNrmr0r;rrOr}ryr~rrJrDrG staticmethodrrrPr7r7r5r8rs(K            rc@seZdZdZdddZdS)rVa 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 ) rhNcCs*tt|j|jf|||dddd|iS)z Returns the discretized `TransferFunction` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `StateSpace` rjrkNrB)rrr}r~rir7r7r8rls z&TransferFunctionContinuous.to_discrete)rhNrLrMrNrmrlr7r7r7r8rVs;rVc@seZdZdZdS)rna 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 ) NrLrMrNrmr7r7r7r8rn/s=rncseZdZdZfddZfddZddZedd Zej d d Zed d Z e j d d Z eddZ e j ddZ ddZ ddZ ddZddZZS)r az 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 ) csxt|dkr&t|dtr&|dS|turl|ddurTtjtg|Ri|Stjtg|Ri|St |S)z9Handle object conversion if input is an instance of `lti`rrrBN) rUrFr-rDr rzrWr0ror/r1r5r7r8r0s& zZerosPolesGain.__new__csJt|dtrdStjfi|d|_d|_d|_|\|_|_|_ dS)z)Initialize the zeros, poles, gain system.rN) rFr-r/r;_zeros_poles_gainrrEgainrr5r7r8r;szZerosPolesGain.__init__cCs.d|jjt|jt|jt|jt|jS)z5Return representation of the `ZerosPolesGain` system.z{}( {}, {}, {}, dt: {} ))rr6rLrrrErrBr?r7r7r8rszZerosPolesGain.__repr__cCs|jS)z%Zeros of the `ZerosPolesGain` system.)rr?r7r7r8rszZerosPolesGain.zeroscCs<t||_t|jjdkr,|jj\|_|_n d|_d|_dSr)rrrUrrr=r<)r@rr7r7r8rs  cCs|jS)z%Poles of the `ZerosPolesGain` system.)rr?r7r7r8rEszZerosPolesGain.polescCst||_dSrr)rr)r@rEr7r7r8rEscCs|jS)z$Gain of the `ZerosPolesGain` system.rr?r7r7r8rszZerosPolesGain.gaincCs ||_dSrrr)r@rr7r7r8rscCs|j|_|j|_|j|_dS)z Copy the parameters of another `ZerosPolesGain` system. Parameters ---------- system : instance of `ZerosPolesGain` The zeros, poles gain system that is to be copied N)rErrr[r7r7r8rs zZerosPolesGain._copycCstt|j|j|ji|jS)z Convert system representation to `TransferFunction`. Returns ------- sys : instance of `TransferFunction` Transfer function of the current system )rrrrErrCr?r7r7r8rJs zZerosPolesGain.to_tfcCs t|S)z Return a copy of the current 'ZerosPolesGain' system. Returns ------- sys : instance of `ZerosPolesGain` The current system (copy) rr?r7r7r8rD s zZerosPolesGain.to_zpkcCstt|j|j|ji|jSr)r!rrrErrCr?r7r7r8rG,s zZerosPolesGain.to_ss)rLrMrNrmr0r;rrOrryrErrrJrDrGrPr7r7r5r8r ps(D           r c@seZdZdZdddZdS)rWa> 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 ) rhNcCs.tt|j|j|jf|||dddd|iS)z Returns the discretized `ZerosPolesGain` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `ZerosPolesGain` rNrrB)r rrrErrir7r7r8rlns z$ZerosPolesGainContinuous.to_discrete)rhNrr7r7r7r8rW:s3rWc@seZdZdZdS)roa, 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 ) Nrr7r7r7r8rosBrocs eZdZdZdZdZfddZfddZdd Zd d Z d d Z ddZ ddZ ddZ ddZddZddZddZeddZejddZedd Zejd!d Zed"d#Zejd$d#Zed%d&Zejd'd&Zd(d)Zd*d+Zd,d-Zd.d/ZZS)0r!ar 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@Ncsxt|dkr&t|dtr&|dS|turl|ddurTtjtg|Ri|Stjtg|Ri|St |S)z4Create new StateSpace object and settle inheritance.rrrBN) rUrFr-rGr!rzrXr0rpr/r1r5r7r8r0 s zStateSpace.__new__csXt|dtrdStjfi|d|_d|_d|_d|_t|\|_ |_ |_ |_ dS)z+Initialize the state space lti/dlti system.rN) rFr-r/r;_A_B_C_DrABCDrr5r7r8r;2szStateSpace.__init__c Cs6d|jjt|jt|jt|jt|jt|jS)z1Return representation of the `StateSpace` system.z{}( {}, {}, {}, {}, dt: {} )) rr6rLrrrrrrBr?r7r7r8rBszStateSpace.__repr__cCst|ttjtttjtfSrr)rFr!rndarrayfloatcomplexnumberintr@otherr7r7r8_check_binop_otherMszStateSpace._check_binop_otherc Cs\||stSt|trt|t|ur,tS|j|jkr@td|jjd}|jjd}t t |jt |j |jft t||f|jff}t t |j |j|j f}t |jt |j|jf}t |j|j}n(|j}t |j |}|j}t |j|}t |j|j|j|j}tt j||dt j||dt j||dt j||dfi|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)rNotImplementedrFr!typerB TypeErrorrrrvstackrrrrrr result_typerrrC) r@rZn1Zn2abcd common_dtyper7r7r8__mul__Qs6        zStateSpace.__mul__cCs||rt|trtS|j}|j}t||j}t||j }t |j |j |j |j }ttj ||dtj ||dtj ||dtj ||dfi|j S)z4Pre-multiply a scalar or matrix (but not StateSpace)r)rrFr!rrrrrrrrrrrCr@rrrrrrr7r7r8__rmul__s   zStateSpace.__rmul__cCs$t|j|j|j |j fi|jS)z8Negate the system (equivalent to pre-multiplying by -1).)r!rrrrrCr?r7r7r8__neg__szStateSpace.__neg__cCsD||stSt|trt|t|urDtdt|dt||j|jkrXtdt|j |j }t |j |j f}t |j|jf}|j|j}nRt |}|jj|jkr|j }|j }|j}|j|}ntd|jjd|jdt |j|j|j|j}tt j||dt j||dt j||dt j||dfi|jS)zM Adds two systems in the sense of frequency domain addition. z Cannot add z and z'Cannot add systems with different `dt`.z1Cannot add systems with incompatible dimensions ()r)rrrFr!rrrBrZ block_diagrrrrrrr atleast_2drrYrrrrCrr7r7r8__add__s<          zStateSpace.__add__cCs||stS|| Srrrrrrr7r7r8__sub__s zStateSpace.__sub__cCs||stS||Srrrrr7r7r8__radd__s zStateSpace.__radd__cCs||stS| |Srrrrr7r7r8__rsub__s zStateSpace.__rsub__cCsD||rt|trtSt|tjr6|jdkr6td|d|S)z$ Divide by a scalar rz3Cannot divide StateSpace by non-scalar numpy arraysr) rrFr!rrrndimrYrrr7r7r8 __truediv__s zStateSpace.__truediv__cCs|jS)z(State matrix of the `StateSpace` system.)rr?r7r7r8rsz StateSpace.AcCst||_dSrr)rr)r@rr7r7r8rscCs|jS)z(Input matrix of the `StateSpace` system.)rr?r7r7r8rsz StateSpace.BcCst||_|jjd|_dS)Nr)rrrrr<)r@rr7r7r8rs cCs|jS)z)Output matrix of the `StateSpace` system.)rr?r7r7r8rsz StateSpace.CcCst||_|jjd|_dS)Nr)rrrrr=)r@rr7r7r8r s cCs|jS)z.Feedthrough matrix of the `StateSpace` system.)rr?r7r7r8rsz StateSpace.DcCst||_dSrr)rr)r@rr7r7r8rscCs$|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)rrrrr[r7r7r8rs zStateSpace._copycKs*tt|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 )rrrrrrrCr@r4r7r7r8rJ)s zStateSpace.to_tfcKs*tt|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 rrrrrrCrr7r7r8rD;s zStateSpace.to_zpkcCs t|S)z Return a copy of the current `StateSpace` system. Returns ------- sys : instance of `StateSpace` The current system (copy) rr?r7r7r8rGMs zStateSpace.to_ss)rLrMrNrmZ__array_priority__Z__array_ufunc__r0r;rrrrrrrrrrrOrryrrrrrJrDrGrPr7r7r5r8r!sFV   <1        r!c@seZdZdZdddZdS)rXa, 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 -------- 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. Examples -------- >>> 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 ) rhNcCs2tt|j|j|j|jf|||dddd|iS)z Returns the discretized `StateSpace` system. Parameters: See `cont2discrete` for details. Returns ------- sys: instance of `dlti` and `StateSpace` rNrrB)r!rrrrrrir7r7r8rls z StateSpaceContinuous.to_discrete)rhNrr7r7r7r8rXZs8rXc@seZdZdZdS)rpa 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 ) Nrr7r7r7r8rps:rpTc Cs t|tr|}n t|tr(tdn t|}t|}t|jdkrRtdt t j |j |j |j|jf\}}}} |jd} |jd} |j} |durt| |j j}t | | f|j j} |ddkr|| d<n6|ddkrt|tt||d| d<ntd|dup4t|ttfr*|dkp4t | }| dkrtt| |j}|sf|t|| j7}||t| fS|d|d}t t ||std|rt|j|}td| D]}| |d|| |<qt| |j}||t| fSt|}|j dkr|ddt j!f}|jd| kr6td |jd| krNtd |st "t #||||gt | | | fg}t|j}|d| d| f}|| dd| f}td| D]*}| |d|||d|| |<qnt "t #||||t | | fgt #t | | | ft $| gt | | d | fg}t|j}|d| d| f}|| | dd| f}|| | | d| f|}td| D]6}| |d|||d||||| |<qt| |jt|| j}||t| fS) al 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.rR)%rFrrHrAttributeErrorrrUrrYmaprrrrrrsizerremptyrrZexpmrrranyrr^allcloserrangernewaxisrridentity)r3r`r^r]interpsysrrrrZn_statesZn_inputsZn_stepsxoutno_inputyoutrBZexpAT_dtiMZexpMTZAdZBdZBd1ZBd0r7r7r8r"sl     $     "      *   4r"cCsBt|}ttt|}|dkr&d}d|}tdd||}|S)aCompute a reasonable set of time samples for the response time. This function is used by `impulse` and `step` to compute the response time when the `T` argument to the function is None. Parameters ---------- A : array_like The system matrix, which is square. n : int The number of time samples to generate. Returns ------- t : ndarray The 1-D array of length `n` of time samples at which the response is to be computed. r?)rZeigvalsminabsrr)rrevalsrZtcrur7r7r8_default_response_timess rcCst|tr|}n t|tr(tdn t|}|durHt|j}nt|j|}|durbd}|durxt|j|}nt |}t |d||dd\}}}||fS)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.NrbrF)r) rFrrHrrrrrrrr")r3r]r^rZrX_hr7r7r8r#s0      r#cCst|tr|}n t|tr(tdn t|}|dur@d}|durVt|j|}nt|}t|j |jj }t ||||dd}|d|dfS)a?Step 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.NrbF)r]rrr) rFrrHrrrrrrrrr")r3r]r^rZrr`rr7r7r8r$s1     r$rbcCsNt|||d\}}dtt|}tt|j|jdtj}|||fS)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() rc4@gf@) r&numpylog10runwrapZarctan2imagrpi)r3rdreymagphaser7r7r8r%as8 r%rgcCst|tr(t|ttfr|}qH|}n t|tr>> 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.N)worN)rFrrr rIrrr<r=rYr r}ravelr~r rrEr)r3rdrerrrr7r7r8r&s"6       r&c@seZdZddZdS)BunchcKs|j|dSrr)__dict__update)r@kwdsr7r7r8r;szBunch.__init__N)rLrMrNr;r7r7r7r8rsrc CsPt|}|jdkrtdt|}|jdkr6td|jdkrHtd|jd|jdkrdtdt||jdkrtd|jdt|ft||jdkrtd t||jdftj|}|D]}t ||k|krtd qt }|d vrtd |d kr$t }t t |s$td|dkr6td|dkrHtd||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.rRzA 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)rrrrY_order_complex_polesrrUr matrix_ranksum_YT_loop _KNV0_loopallisreal) rrrErjrtolmaxiterrp update_loopr7r7r8 _valid_inputssD         rcCst|t|}g}t|t|dkD]&}t||vr0||t|fq0t||f}|jdt|krt d|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) rsortrrconjextendrrrUrY)rEZ ordered_polesZim_polesrr7r7r8r0 src Cs~tj||dd}t|dd\}}t||||j}t||dddf} t| dsz| tj| } | |dd|f<dS)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 rZaxisfullmodeNrr)rdeletes_qrrr^rrnorm) rker_poletransfer_matrixjrEZtransfer_matrix_not_jQRZ mat_ker_pjZyjZxjr7r7r8_KNV0D s   r c Cs|dddtjf}|dddtjf}tt||jt||jt||j||}tj|\}} } |jddddtjf\} } | ddddtjf\} }t|dd|tjf|dd|tjff}t| d| dst||| }t||| }t||f}nptt||t ||j ftt ||j ||ff}tt| | ft| |ff}t||}tt||j|}t|ds*t d|tj |}|d|dd|fj ddf|dd|f<||dd|fj dddf|dd|f<n\|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 NrrRrr) rrrr^rZsvdrrrrrsqrtr)rr rrr rwvmZumsmvmmu1mu2Znu1Znu2&transfer_matrix_j_mo_transfer_matrix_jZker_pole_imo_mu1Zker_pole_i_nu1Zker_pole_mu_nu ker_pole_ijZ mu_nu_matrixZtransfer_matrix_ijr7r7r8_YT_reals sb      rc Cs&td|dddtjf}td|dddtjf}|d|}||}ttt|jt|t|jtt||j|} tj| \} } tt | } | dd| dtjf} | dd| dtjf}|dd|tjfd|dd|tjf}t t | | dt | | dsDt|| }nt | |f}t||}tt|t|j|}t |ds|tj |}t |dddf|dd|f<t|dddf|dd|f<nDt |dddf|dd|f<t|dddf|dd|f<dS)zP Applies algorithm from YT section 6.2 page 20 related to complex pairs rRNr r?r)rrrrrr^reigZargsortrrrrrr)rr rrr urZuirwrrZe_valZe_vecZ e_val_idxrrrZ ker_pole_muZmu1_mu2_matrixZtransfer_matrix_i_jr7r7r8 _YT_complex sD $   "$"rcCs|t|jd}|d}|dkr2|gdgg}nggg}t|dt|dd} td||d} |dd| |dd| d|d| |d| dtd|d} |dd| d|dd| |dkrt|dr|dd|dd|d| |d| dtd||d} | D]<} td|dD]&} |d| |d| | qhqV|dkrt|dr|dd|dd|d| |d| dtd||d} | D]Z} t|d|dD]@} | | }||kr:| | |}|d| |d|qq|dkrt|dr|dd|dd|d| |d| dtd|dD]&} |d| |d| |q|dkr t|dr |dd|dd|d| |d| dt|j d}d}d}||kr|st tj |}|D]\} } | | kr| dksJdt|| sJdt |||| |ntj|| | fdd}t|dd \}}t|| r2t|| s Jd t|t|||| | n2t|| sTJd t|t|||| | q~tttdt tj |f}t |||}||kr|ttdkrd }|d7}qX|||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 rrRrFzi!=0 for KNV call in YTzcalling KNV on a complex polerrrz"mixing real and complex in YT_realT)rrrZarangerUrappendrarrayr^rrdetr rrstrrrmaxrspacing)rrrErrrZnb_realZhnbZ update_orderZr_compZr_pZr_jr rZidx_1stopnb_trydet_transfer_matrixbZtransfer_matrix_not_i_jr rdet_transfer_matrixcur_rtolr7r7r8r s        rc Csd}d}||kr|sttj|}t|jdD]} t|||| |q4ttt dttj|f} t| || } | |kr| tt dkrd}|d7}q|| |fS)zI Loop over all poles one by one and apply KNV method 0 algorithm FrrT) rrrrrrr r rr!) rrrErrrr"r#r$r r%r&r7r7r8rb s    rrMbP?c" Cs<t||||||\}}d}d}t|dd\} } tj|} | ddd| f} | dd| df} | d| ddf} |jd| krbt|j}d}||jdkr(||}t||||f<t|rt | |||df<t|||d|df<t |||d|f<|d7}|d7}qtjj |||ddd}t |jd}tj }tj }ng}d}t |jdD]}|rd}qxt| j|||t |jdj}t|dd\}}|dd|jddf}tj|dd ddtjf}|tj|}t||rHtt|t |g}|||gd }n |||dkrb|}nt||f}qx| dkr|||||||\}}}|s|dkrd |d |d }tj|dd|t}d}||jddkrjt||r^|dd|f}|dd|df}|d||dd|f<|d||dd|df<|d7}|d7}qzBtj|jtt||jj}tj| t| j||}Wn4tjjy} ztd| WYd} ~ n d} ~ 00| }t|}t}!||!_ t!tj"|t||d|!_#||!_$||!_%||!_&||!_'|!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 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. Examples -------- A simple example demonstrating real pole placement using both KNV and YT algorithms. This is example number 1 from section 4 of the reference KNV publication ([1]_): >>> 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)ZrcondFrTzSConvergence was not reached after maxiter iterations. You asked for a tolerance of z , we got .rR) stacklevelrzfThe poles you've chosen can't be placed. Check the controllability matrix and try another set of poles)(rrrrrrrrrrZlstsqeyenanrrr^rrrrrrwarningswarnZastyperrZsolveZdiagZ LinAlgErrorrYr gain_matrixrrZcomputed_polesZrequested_polesrrnb_iter)"rrrErjrrrr&r0rwzZrankBZu0u1Z diag_polesidxrr/rrZskip_conjugater Z pole_space_jr rZ ker_pole_jZtransfer_matrix_jr"err_msgrelZimgreZfull_state_feedbackr7r7r8r'| s6    (           r'c Csnt|trtdn$t|ts8t|ddd|di}t|t}|}t|}|jdkrjt |j }|durt |}|d|j }n |d}t t||j d}t||jjdf}t||jjdf}tjd||d} |durt|jjdf|dddf<nt||dddf<|dur8|} n4t |jdkrZ|ddtjf}t||dd | } td|dD]} t|j|| ddft|j| | ddf|| dddf<t|j|| ddft|j| | ddf|| ddf<qzt|j||dddft|j| |dddf||dddf<|rb| ||fS| |fSdS) a Simulate output of a discrete-time linear 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) 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. t : array_like, optional The time steps at which the input is defined. If `t` is given, it must be the same length as `u`, and the final value in `t` determines the number of steps returned in the output. x0 : array_like, optional The initial conditions on the state vector (zero by default). Returns ------- tout : ndarray Time values for the output, as a 1-D array. yout : ndarray System response, as a 1-D array. xout : ndarray, optional Time-evolution of the state-vector. Only generated if the input is a `StateSpace` system. See Also -------- lsim, dstep, dimpulse, cont2discrete Examples -------- A simple integrator transfer function with a discrete time step of 1.0 could be implemented as: >>> 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.NrrBrrr)r})k)rFrrrr!rHrrrrr^rUrBrfloorrrrrrrrrrrrr) r3rwrurtZ is_ss_inputZ out_samplesZstoptimerrtoutZu_dtrr7r7r8r( sL9        "  r(c Cst|tr|}n2t|tr(tdnt|ddd|di}|durRd}|durttjd||j|dd}n t|}d}t d|j D]`}t |j d|j f}d |d|f<t ||||d }|dur|d f}n||d f}|d}q||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 -------- 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.NrrBrbrFZendpointrrurtr)rFrrHrrrrrBrrr<rrr( r3rtrurerrrwZ one_outputr9r7r7r8r*O s(2        r*c Cs t|tr|}n2t|tr(tdnt|ddd|di}|durRd}|durttjd||j|dd}n t|}d}t d|j D]r}t |j d|j f}t |j df|dd|f<t||||d }|dur|d f}n||d f}|d}q||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 -------- 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.NrrBrbrFr:r;r)rFrrHrrrrrBrrr<rrrr(r<r7r7r8r) s(1       r)FcCst|ts6t|trtdt|ddd|di}t|trH|}t|ttfs^td|j dksr|j dkrztd|dur|}n|}t|trt |j |j\}}t||||d\}}n&t|trt|j|j|j||d\}}||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 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.NrrBzUnknown system typerz?dfreqresp requires a SISO (single input, single output) system.)rrx)rFrrrr!rKrr rYr<r=rr}rr~r r rrEr)r3rdrerxrr}r~rr7r7r8r+ s*@      r+cCsbt|||d\}}t|tr$|j}n|d}dtt|}ttt |}||||fS)a7 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] 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 -------- >>> 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) Equivalent: sys.bode() >>> w, mag, phase = signal.dbode(sys) >>> plt.figure() >>> plt.semilogx(w, mag) # Bode magnitude plot >>> plt.figure() >>> plt.semilogx(w, phase) # Bode phase plot >>> plt.show() rcrr) r+rFrrBrrrZrad2degrZangle)r3rdrerrBrrr7r7r8r,` s> r,)NT)NNN)NNN)Nrb)Nrg)rr'r()NN)NNN)NNN)NrgF)Nrb)Frmr-Z scipy.linalgrrZscipyrZscipy.interpolaterZ_filter_designrrrr r r r Z_lti_conversionr rrrrrrrrrrrrrrrrrr__all__r-rrrrVrnr rWror!rXrpr"rr#r$r%r&rrrr rrrrr'r(r*r)r+r,r7r7r7r8sj   $$,V(@xMAKFFJ> X F C @ W3/A3{ a t W V d