scipy sp1.5-0.3.1 · OCaml Package

type tag = [

| `TransferFunctionContinuous

]

type t = [ `Object | `TransferFunctionContinuous ] 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

Continuous-time Linear Time Invariant system in transfer function form.

Represents the system as the transfer function :math:`H(s)=\sum_=0^N bN-i s^i / \sum_j=0^M aM-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) = \fracs^2 + 3s + 3s^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 )

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

val 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.

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 a continuous-time system. See `impulse` 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 a continuous-time system to input `U`. See `lsim` 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 a continuous-time system. See `step` for details.

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

Returns the discretized `TransferFunction` system.

Parameters: See `cont2discrete` for details.

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

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

Return a copy of the current `TransferFunction` system.

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

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

Convert system representation to `ZerosPolesGain`.

Returns ------- sys : instance of `ZerosPolesGain` Zeros, poles, gain representation of the current system

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.

package scipy