package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `Dlti
]
type t = [ `Dlti | `Object ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val create : ?kwargs:(string * Py.Object.t) list -> Py.Object.t list -> t

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 )

>>> signal.dlti(1, 2, 3, 4, 5, dt=0.1) ZerosPolesGainDiscrete( array(1, 2), array(3, 4), 5, dt: 0.1 )

>>> signal.dlti(3, 4, 1, 2, dt=0.1) TransferFunctionDiscrete( array(3., 4.), array(1., 2.), dt: 0.1 )

val bode : ?w:Py.Object.t -> ?n:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

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

Transfer function: H(z) = 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()

val freqresp : ?w:Py.Object.t -> ?n:Py.Object.t -> ?whole:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

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.

val impulse : ?x0:Py.Object.t -> ?t:Py.Object.t -> ?n:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Return the impulse response of the discrete-time `dlti` system. See `dimpulse` for details.

val output : ?x0:Py.Object.t -> u:Py.Object.t -> t:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Return the response of the discrete-time system to input `u`. See `dlsim` for details.

val step : ?x0:Py.Object.t -> ?t:Py.Object.t -> ?n:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Return the step response of the discrete-time `dlti` system. See `dstep` for details.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Stdlib.Format.formatter -> t -> unit

Pretty-print the object to a formatter.