Classe « StateSpace »

Informations générales

Héritage

builtins.object
    LinearTimeInvariant
        StateSpace

Définition

class StateSpace(LinearTimeInvariant):

help(StateSpace)

Linear Time Invariant system in state-space form.

Represents the system as the continuous-time, first order differential
equation :math:`\dot{x} = A x + B u` or the discrete-time difference
equation :math:`x[k+1] = A x[k] + B u[k]`. `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 4 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
>>> import numpy as np
>>> 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
)

Constructeur(s)

Signature du constructeur	Description
__new__(cls, system, *kwargs)	Create new StateSpace object and settle inheritance. _{[extrait de __new__.__doc__]}
__init__(self, system, *kwargs)	Initialize the state space lti/dlti system. _{[extrait de __init__.__doc__]}

Liste des propriétés

Nom de la propriété	Description
A	State matrix of the `StateSpace` system. _{[extrait de A.__doc__]}
B	Input matrix of the `StateSpace` system. _{[extrait de B.__doc__]}
C	Output matrix of the `StateSpace` system. _{[extrait de C.__doc__]}
D	Feedthrough matrix of the `StateSpace` system. _{[extrait de D.__doc__]}
dt	Return the sampling time of the system, `None` for `lti` systems. _{[extrait de dt.__doc__]}
poles	Poles of the system. _{[extrait de poles.__doc__]}
zeros	Zeros of the system. _{[extrait de zeros.__doc__]}

Liste des opérateurs

Signature de l'opérateur	Description
__add__(self, other)
__mul__(self, other)
__neg__(self)	Negate the system (equivalent to pre-multiplying by -1). _{[extrait de __neg__.__doc__]}
__radd__(self, other)
__rmul__(self, other)	Pre-multiply a scalar or matrix (but not StateSpace) _{[extrait de __rmul__.__doc__]}
__rsub__(self, other)
__sub__(self, other)
__truediv__(self, other)

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__repr__(self)	Return representation of the `StateSpace` system. _{[extrait de __repr__.__doc__]}
to_ss(self)
to_tf(self, **kwargs)
to_zpk(self, **kwargs)