package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Signal.LtiSource

Sourcetype tag = [
  1. | `Lti
]
Sourcetype t = [ `Lti | `Object ] Obj.t
Sourceval of_pyobject : Py.Object.t -> t
Sourceval to_pyobject : [> tag ] Obj.t -> Py.Object.t
Sourceval create : Py.Object.t list -> t

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 )

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

>>> signal.lti(3, 4, 1, 2) TransferFunctionContinuous( array(3., 4.), array(1., 2.), dt: None )

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

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()

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

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.

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

Return the impulse response of a continuous-time system. See `impulse` for details.

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

Return the response of a continuous-time system to input `U`. See `lsim` for details.

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

Return the step response of a continuous-time system. See `step` for details.

Sourceval to_discrete : ?method_:Py.Object.t -> ?alpha:Py.Object.t -> dt:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Return a discretized version of the current system.

Parameters: See `cont2discrete` for details.

Returns ------- sys: instance of `dlti`

Sourceval to_string : t -> string

Print the object to a human-readable representation.

Sourceval show : t -> string

Print the object to a human-readable representation.

Sourceval pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.