package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `StateSpace
]
type t = [ `Object | `StateSpace ] 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

Linear Time Invariant system in state-space form.

Represents the system as the continuous-time, first order differential equation :math:`\dotx = A x + B u` or the discrete-time difference equation :math:`xk+1 = A xk + B uk`. `StateSpace` systems inherit additional functionality from the `lti`, respectively the `dlti` classes, depending on which system representation is used.

Parameters ---------- *system: arguments The `StateSpace` class can be instantiated with 1 or 3 arguments. The following gives the number of input arguments and their interpretation:

* 1: `lti` or `dlti` system: (`StateSpace`, `TransferFunction` or `ZerosPolesGain`) * 4: array_like: (A, B, C, D) dt: float, optional Sampling time s of the discrete-time systems. Defaults to `None` (continuous-time). Must be specified as a keyword argument, for example, ``dt=0.1``.

See Also -------- TransferFunction, ZerosPolesGain, lti, dlti ss2zpk, ss2tf, zpk2sos

Notes ----- Changing the value of properties that are not part of the `StateSpace` system representation (such as `zeros` or `poles`) 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

>>> a = np.array([0, 1], [0, 0]) >>> b = np.array([0], [1]) >>> c = np.array([1, 0]) >>> d = np.array([0])

>>> sys = signal.StateSpace(a, b, c, d) >>> print(sys) StateSpaceContinuous( array([0, 1], [0, 0]), array([0], [1]), array([1, 0]), array([0]), dt: None )

>>> sys.to_discrete(0.1) StateSpaceDiscrete( array([1. , 0.1], [0. , 1. ]), array([0.005], [0.1 ]), array([1, 0]), array([0]), dt: 0.1 )

>>> a = np.array([1, 0.1], [0, 1]) >>> b = np.array([0.005], [0.1])

>>> signal.StateSpace(a, b, c, d, dt=0.1) StateSpaceDiscrete( array([1. , 0.1], [0. , 1. ]), array([0.005], [0.1 ]), array([1, 0]), array([0]), dt: 0.1 )

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

Return a copy of the current `StateSpace` system.

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

val to_tf : ?kwargs:(string * Py.Object.t) list -> [> tag ] Obj.t -> Py.Object.t

Convert system representation to `TransferFunction`.

Parameters ---------- kwargs : dict, optional Additional keywords passed to `ss2zpk`

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

val to_zpk : ?kwargs:(string * Py.Object.t) list -> [> tag ] Obj.t -> Py.Object.t

Convert system representation to `ZerosPolesGain`.

Parameters ---------- kwargs : dict, optional Additional keywords passed to `ss2zpk`

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.