# pole

Poles of dynamic system

## Syntax

``P = pole(sys)``
``P = pole(sys,J1,...,JN)``

## Description

example

````P = pole(sys)` returns the poles of the SISO or MIMO dynamic system model `sys`. The output is expressed as the reciprocal of the time units specified in `sys.TimeUnit`. The poles of a dynamic system determine the stability and response of the system.An open-loop linear time-invariant system is stable if: In continuous-time, all the poles of the transfer function have negative real parts. When the poles are visualized on the complex s-plane, then they must all lie in the left-half plane (LHP) to ensure stability.In discrete-time, all the poles must have a magnitude strictly smaller than one, that is they must all lie inside the unit circle. ```

example

````P = pole(sys,J1,...,JN)` returns the poles `P` of the entries in model array `sys` with subscripts `(J1,...,JN)`.```

## Examples

collapse all

Compute the poles of the following discrete-time transfer function:

`$sys\left(z\right)=\frac{0.0478z-0.0464}{{z}^{2}-1.81z+0.9048}$`

```sys = tf([0.04798 0.0464],[1 -1.81 0.9048],0.1); P = pole(sys)```
```P = 2×1 complex 0.9050 + 0.2929i 0.9050 - 0.2929i ```

For stable discrete systems, all their poles must have a magnitude strictly smaller than one, that is they must all lie inside the unit circle. The poles in this example are a pair of complex conjugates, and lie inside the unit circle. Hence, the system `sys` is stable.

Calculate the poles of following transfer function:

`$sys\left(s\right)=\frac{4.2{s}^{2}+0.25s-0.004}{{s}^{2}+9.6s+17}$`

```sys = tf([4.2,0.25,-0.004],[1,9.6,17]); P = pole(sys)```
```P = 2×1 -7.2576 -2.3424 ```

For stable continuous systems, all their poles must have negative real parts. `sys` is stable since the poles are negative, that is, they lie in the left half of the complex plane.

For this example, load `invertedPendulumArray.mat`, which contains a 3-by-3 array of inverted pendulum models. The mass of the pendulum varies as you move from model to model along a single column of `sys`, and the length of the pendulum varies as you move along a single row. The mass values used are 100g, 200g and 300g, and the pendulum lengths used are 3m, 2m and 1m respectively.

`$\begin{array}{cccc}& Column\phantom{\rule{0.5em}{0ex}}1& Column\phantom{\rule{0.5em}{0ex}}2& Column\phantom{\rule{0.5em}{0ex}}3\\ Row\phantom{\rule{0.5em}{0ex}}1& 100g,3m& 100g,2m& 100g,1m\\ Row\phantom{\rule{0.5em}{0ex}}2& 200g,3m& 200g,2m& 200g,1m\\ Row\phantom{\rule{0.5em}{0ex}}3& 300g,3m& 300g,2m& 300g,1m\end{array}$`

```load('invertedPendulumArray.mat','sys'); size(sys)```
```3x3 array of transfer functions. Each model has 1 outputs and 1 inputs. ```

Find poles of the model array.

```P = pole(sys); P(:,:,2,1)```
```ans = 3×1 2.1071 -2.1642 -0.1426 ```

`P(:,:,2,1)` corresponds to the poles of the model with 200g pendulum weight and 3m length.

## Input Arguments

collapse all

Dynamic system, specified as a SISO or MIMO dynamic system model, or an array of SISO or MIMO dynamic system models. Dynamic systems that you can use include continuous-time or discrete-time numeric LTI models such as `tf`, `zpk`, or `ss` models.

If `sys` is a generalized state-space model `genss` or an uncertain state-space model `uss`, `pole` returns the poles of the current or nominal value of `sys`. If `sys` is an array of models, `pole` returns the poles of the model corresponding to its subscript `J1,...,JN` in `sys`. For more information on model arrays, see Model Arrays.

Indices of models in array whose poles you want to extract, specified as a positive integer. You can provide as many indices as there are array dimensions in `sys`. For example, if `sys` is a 4-by-5 array of dynamic system models, the following command extracts the poles for entry (2,3) in the array.

`P = pole(sys,2,3);`

## Output Arguments

collapse all

Poles of the dynamic system, returned as a scalar or an array. If `sys` is:

• A single model, then `P` is a column vector of poles of the dynamic system model `sys`

• A model array, then `P` is an array of poles of each model in `sys`

`P` is expressed as the reciprocal of the time units specified in `sys.TimeUnit`. For example, pole is expressed in 1/minute if `sys.TimeUnit` = `'minutes'`.

Depending on the type of system model, poles are computed in the following way:

• For state-space models, the poles are the eigenvalues of the A matrix, or the generalized eigenvalues of AλE in the descriptor case.

• For SISO transfer functions or zero-pole-gain models, the poles are the denominator roots. For more information, see `roots`.

• For MIMO transfer functions (or zero-pole-gain models), the poles are returned as the union of the poles for each SISO entry. If some I/O pairs have a common denominator, the roots of such I/O pair denominator are counted only once.

## Limitations

• Multiple poles are numerically sensitive and cannot be computed with high accuracy. A pole λ with multiplicity m typically results in a cluster of computed poles distributed on a circle with center λ and radius of order

`$\rho \approx {\epsilon }^{1/m},$`

where ε is the relative machine precision (`eps`).

• If `sys` has internal delays, poles are obtained by first setting all internal delays to zero so that the system has a finite number of poles, thereby creating a zero-order Padé approximation. For some systems, setting delays to zero creates singular algebraic loops, which result in either improper or ill-defined, zero-delay approximations. For these systems, `pole` returns an error.
To assess the stability of models with internal delays, use `step` or `impulse`.