pole

Poles of dynamic system

Syntax

P = pole(sys)

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

P = pole(___,Name=Value)

Description

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.

For sparse state-space models, this syntax computes up to first 1000 poles with smallest magnitude. (since R2025a)

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

P = pole(___,Name=Value) computes a subset of poles of a sparse model sys based on one or more specified name-value arguments. If you do not specify any name-value arguments, the function computes up to the first 1000 poles with smallest magnitude. The function ignores name-value arguments when sys is a nonsparse model. (since R2025a)

Examples

Poles of Discrete-Time Transfer Function

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.

Poles of Transfer Function

Calculate the poles of following transfer function:

$$sys\left(s\right)=\frac{4.2s^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.

Poles of Models in an Array

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}& Column1& Column2& Column3\\ Row1& 100g,3m& 100g,2m& 100g,1m\\ Row2& 200g,3m& 200g,2m& 200g,1m\\ Row3& 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.

Compute Poles of Sparse Models

Since R2025a

This example shows how to compute poles of a sparse beam model. For sparse state-space models, pole computes a subset of poles based on a frequency range of interest.

Load the model.

load linBeam.mat
size(sys)

Sparse second-order model with 1 outputs, 1 inputs, and 3303 degrees of freedom.

Sparse models are often large-scale and computing all poles may be infeasible or computationally expensive. By default, the pole function computes up to first 1000 poles with the smallest magnitude.

p = pole(sys);
size(p)

ans = 1×2

        1000           1

To avoid computing a large number of poles, you can specify additional options such as a frequency range of interest. Typically, you specify a low-frequency band and the function computes only poles with natural frequency in the range.

p2 = pole(sys,Focus=[0 1e4]);
size(p2)

ans = 1×2

     4     1

Input Arguments

sys — Dynamic system

dynamic system model | model array

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.

If sys is a sparse state-space model (sparss or mechss), the software computes a subset of poles in a specified frequency band of focus. For sparse models, use the name-value arguments to specify computation options. If you do not specify any options, the software computes up to the first 1000 poles with smallest magnitude. For mechss models with Rayleigh damping, the software computes poles from the eigenvalues of (K,M). Otherwise, the software computes the poles from the equivalent sparss model. (since R2025a)

J1,...,JN — Indices of models in array whose poles you want to extract

positive integer

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

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Example: B = pole(sparseSys,Focus=[0 10],Display="off")

Focus — Frequency range of interest

[0 Inf] (default) | vector

Since R2025a

Frequency range of interest, specified as a vector of form [fmin,fmax]. When you specify a frequency range of focus, the algorithm computes only the poles with natural frequency in this range. For discrete-time models, the software approximates the equivalent natural frequency through Tustin transform.

For symmetric semi-definite sparse models, you can specify any frequency range with 0 ≤ fmin < fmax ≤ ∞. For nonsymmetric sparss models, you must specify frequency range as either [0,fmax] or [fmin,inf].

Since the software computes all poles in the specified frequency range, you typically specify a low-frequency range to limit computing a large number of poles. By default, the focus is unspecified ([0 Inf]) and the algorithm computes up to MaxNumber poles.

MaxNumber — Maximum number of poles and zeros to compute

1000 (default) | positive integer

Since R2025a

Maximum number of poles and zeros to compute, specified as a positive integer. This value limits the number of poles computed by the algorithm.

Shift — Spectral shift

0 (default) | finite scalar

Since R2025a

Spectral shift, specified as a finite scalar.

The software computes poles with the natural frequency in the specified range [0,fmax] using inverse power iterations for A-sigma*E, which obtains eigenvalues closest to shift sigma. When A is singular and sigma is zero, the algorithm fails as no inverse exists. Therefore, for sparse models with integral action (s = 0 or at z = 1 for discrete-time models), you can use this option to implicitly shift poles or zeros to the value closest to this shift value. Specify a shift value that is not equal to an existing pole value of the original model.

Tolerance — Accuracy of computed poles

1e-12 (default) | positive finite scalar

Since R2025a

Tolerance for accuracy of computed poles, specified as a positive finite scalar. This value controls the convergence of computed eigenvalues in inverse power iterations.

Display — Show or hide progress report

"on" (default) | "off"

Since R2025a

Show or hide progress report, specified as either "off" or "on".

Output Arguments

P — Poles of the dynamic system

column vector | array

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 sparse state-space models, the poles are a subset of eigenvalues obtained using inverse power iterations [1]. (since R2025a)

• 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).

  For more information on multiple poles, see Sensitivity of Multiple Roots.

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

Algorithms

For sparse-state space models, pole uses the Krylov--Schur algorithm [1] for inverse power iterations to compute poles in the specified frequency band.

References

[1] Stewart, G. W. “A Krylov--Schur Algorithm for Large Eigenproblems.” SIAM Journal on Matrix Analysis and Applications 23, no. 3 (January 2002): 601–14. https://doi.org/10.1137/S0895479800371529.

Version History

Introduced before R2006a

R2025a: Sparse Model Support: Compute subset of poles in frequency range of interest

You can now compute a subset of poles for sparse state-space models in a specified frequency range of interest. By default, the function computes first 1000 poles with the smallest magnitude. To avoid computing a large number of poles, you can use the new syntax p = pole(sparseSys,Name=Value) to specify options such as frequency range of interest or maximum number of poles to compute.