package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `ZerosPolesGainDiscrete
]
type t = [ `Object | `ZerosPolesGainDiscrete ] 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 in zeros, poles, gain form.

Represents the system as the discrete-time transfer function :math:`H(s)=k \prod_i (s - zi) / \prod_j (s - pj)`, where :math:`k` is the `gain`, :math:`z` 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 -------- >>> from scipy import signal

Transfer function: H(s) = 5(s - 1)(s - 2) / (s - 3)(s - 4)

>>> signal.ZerosPolesGain(1, 2, 3, 4, 5) ZerosPolesGainContinuous( array(1, 2), array(3, 4), 5, dt: None )

Transfer function: H(z) = 5(z - 1)(z - 2) / (z - 3)(z - 4)

>>> signal.ZerosPolesGain(1, 2, 3, 4, 5, dt=0.1) ZerosPolesGainDiscrete( array(1, 2), array(3, 4), 5, 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_ss : [> tag ] Obj.t -> Py.Object.t

Convert system representation to `StateSpace`.

Returns ------- sys : instance of `StateSpace` State space model of the current system

val to_tf : [> tag ] Obj.t -> Py.Object.t

Convert system representation to `TransferFunction`.

Returns ------- sys : instance of `TransferFunction` Transfer function of the current system

val to_zpk : [> tag ] Obj.t -> Py.Object.t

Return a copy of the current 'ZerosPolesGain' system.

Returns ------- sys : instance of `ZerosPolesGain` The current system (copy)

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.