Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé

Module « scipy.signal »

Classe « dlti »

Informations générales

Héritage

builtins.object
    LinearTimeInvariant
        dlti

Définition

class dlti(LinearTimeInvariant):

help(dlti)

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
)

Constructeur(s)

Signature du constructeur	Description
__new__(cls, *system, **kwargs)	Create an instance of the appropriate subclass. [extrait de __new__.__doc__]
__init__(self, *system, **kwargs)

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Méthodes héritées de la classe LinearTimeInvariant

__init_subclass__, __subclasshook__

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getattribute__, __getstate__, __hash__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__

Vous êtes un professionnel et vous avez besoin d'une formation ? Deep Learning avec Python
et Keras et Tensorflow Voir le programme détaillé