pade

Padé approximation of models with time delay

Syntax

[num,den] = pade(T,N)

pade(T,N)

sysx = pade(sys,N)

sysx = pade(sys,NU,NY,NINT)

Description

pade approximates time delays for continuous-time LTI models. Such approximations are useful to model time delay effects such as transport and computation delays within the context of continuous-time systems. The Laplace transform of a time delay of T seconds is exp(–sT). This exponential transfer function is approximated by a rational transfer function using the Padé approximation formulas from [1].

To approximate discrete-time models, use absorbDelay.

See Time Delays in Linear Systems for more information about models with time delays.

[num,den] = pade(T,N) returns the Padé approximation of order N of the time delay T in transfer function form. The output row vectors num and den contain the numerator and denominator coefficients in descending powers of s. num and den are Nth-order polynomials.

pade(T,N) plots the step and phase responses of the Nth-order Padé approximation and compares them with the exact responses of the model with time delay T. The resultant Padé approximation has unit gain at all frequencies.

sysx = pade(sys,N) produces a delay-free approximation sysx of the continuous-time delay system sys. All delays are replaced by their Nth-order Padé approximation.

sysx = pade(sys,NU,NY,NINT) specifies independent approximation orders for each input, output, and I/O or internal delay using vectors NU, NY, and NINT, respectively. You can use scalar values for NU, NY, or NINT to specify a uniform approximation order. You can also set some entries of NU, NY, or NINT to Inf to prevent approximation of the corresponding delays.

Examples

Second-Order Padé Approximation

For this example, compute the delay-free numerator and denominator coefficients for a time delay of 1.8 seconds for a second-order system.

T = 1.8;
N = 2;
[num,den] = pade(T,N)

num = 1×3

    1.0000   -3.3333    3.7037

den = 1×3

    1.0000    3.3333    3.7037

You can also plot the step and phase response of the delay-free approximation and the original system with time delay. Use the pade command without output arguments to generate the comparison plots.

pade(T,N)

Padé Approximation of Continuous-Time Open-Loop Model

For this example, find the Padé approximation of the following continuous-time open loop system.

Create the open-loop system with an output delay.

s = tf('s');
T = 2.6;
sys = exp(-T*s)/(s^2+0.9*s+1)

sys =
 
                       1
  exp(-2.6*s) * ---------------
                s^2 + 0.9 s + 1
 
Continuous-time transfer function.

sys is a second-order transfer function (tf) object with a time delay.

Next, compute the first-order Padé approximation of sys.

sysx = pade(sys,1)

sysx =
 
             -s + 0.7692
  ----------------------------------
  s^3 + 1.669 s^2 + 1.692 s + 0.7692
 
Continuous-time transfer function.

pade replaces all time delays in sys with a first-order approximation. Therefore, sysx is a third-order transfer function with no delays.

You can also plot and compare the step and phase response of the delay-free approximated model and the model with time-delay. Use the time delay and order values to create the plot.

pade(T,1)

Third-Order Padé Approximation

Compute a third-order Padé approximation of a 0.1-second I/O delay.

s = tf('s');
sys = exp(-0.1*s);    
sysx = pade(sys,3)

sysx =
 
  -s^3 + 120 s^2 - 6000 s + 1.2e05
  --------------------------------
  s^3 + 120 s^2 + 6000 s + 1.2e05
 
Continuous-time transfer function.

Here, sys is a dynamic system representation of the exact time delay of 0.1 s. sysx is a transfer function that approximates that delay.

Compare the time and frequency responses of the true delay and its approximation. Calling the pade command without output arguments generates the comparison plots. In this case the first argument to pade is just the magnitude of the exact time delay, rather than a dynamic system representing the time delay.

pade(0.1,3)

Padé Approximation of MIMO State-Space Model

For this example, consider the MIMO state-space model sys contained in ssModel.mat. sys has two inputs and three outputs, and contains input, output and internal delays.

Load the data and examine sys.

load('ssModel.mat','sys')
sys

sys =
 
  A = 
            x1       x2
   x1    2.893    1.497
   x2  -0.1138  -0.5279
 
  B = 
             u1        u2
   x1    -1.334    -4.155
   x2     1.127  -0.06161
 
  C = 
            x1       x2
   y1   -2.416  -0.6317
   y2    1.688    1.063
   y3    3.509     1.84
 
  D = 
           u1      u2
   y1   1.019   1.999
   y2       0  -3.658
   y3       0  -5.885
 
  (values computed with all internal delays set to zero)

  Input delays (seconds): 1.5  0.3 
  Output delays (seconds): 0.2  0.8  1.3 
  Internal delays (seconds): 2.1  1.3 
 
Continuous-time state-space model.

Specify the approximation orders for the input, output, and internal delays, and compute the Padé approximation. Set approximation orders to Inf to prevent approximation of the corresponding delays.

NU = [3 Inf];
NY = [1 Inf 2];
NINT = [Inf 2];
sysx = pade(sys,NU,NY,NINT)

sysx =
 
  A = 
             x1       x2       x3       x4       x5       x6       x7       x8       x9      x10
   x1       -10        0        0   -9.665   -2.527   -7.305        0     16.3        0    4.527
   x2         0   -4.615    -3.55    14.04    7.358    21.51        0        0        0        0
   x3         0        2        0        0        0        0        0        0        0        0
   x4         0        0        0    2.893    1.497    4.115        0   -5.335        0   -1.482
   x5         0        0        0  -0.1138  -0.5279  -0.2169        0     4.51        0    1.253
   x6         0        0        0   -8.011   -3.193   -4.615    -3.55        0        0        0
   x7         0        0        0        0        0        2        0        0        0        0
   x8         0        0        0        0        0        0        0       -8   -6.667   -2.222
   x9         0        0        0        0        0        0        0        4        0        0
   x10        0        0        0        0        0        0        0        0        4        0
 
  B = 
              u1        u2
   x1     -4.075     7.996
   x2          0    -23.54
   x3          0         0
   x4      1.334    -4.155
   x5     -1.127  -0.06161
   x6          0      10.1
   x7          0         0
   x8          4         0
   x9          0         0
   x10         0         0
 
  C = 
           x1      x2      x3      x4      x5      x6      x7      x8      x9     x10
   y1       5       0       0   2.416  0.6317   1.826       0  -4.075       0  -1.132
   y2       0       0       0   1.688   1.063   3.074       0       0       0       0
   y3       0  -2.308       0   3.509    1.84   5.377       0       0       0       0
 
  D = 
           u1      u2
   y1   1.019  -1.999
   y2       0  -3.658
   y3       0  -5.885
 
  (values computed with all internal delays set to zero)

  Input delays (seconds): 0  0.3 
  Output delays (seconds): 0  0.8  0 
  Internal delays (seconds): 2.1 
 
Continuous-time state-space model.

The resultant approximation sysx still has specific input, output, and internal delays where the corresponding approximation orders are Inf.

Input Arguments

T — Time delay

positive scalar

Time delay value, specified as a positive scalar. The Padé approximation of a zero delay (T = 0) is always unit gain.

N — Desired order of continuous-time approximation model

positive integer

Desired order of the continuous-time approximation model, specified as a positive integer.

sys — Dynamic system with time delay

dynamic system model

Dynamic system with time delay, specified as a SISO or MIMO dynamic system model. Dynamic systems that you can use include:

• Continuous-time LTI models, such as tf, zpk, and ss models.

• Sparse models, such as sparss and mechss models.

• Generalized or uncertain LTI models such as genss or uss (Robust Control Toolbox) models. (Using uncertain models requires a Robust Control Toolbox™ license.)

  The resulting model assumes

  • Current values of the tunable components for tunable control design blocks

  • Nominal model values for uncertain control design blocks

• Frequency response frd models. For frequency response models, use the delay2z command to absorb delays into the frequency response without approximation.

For discrete-time models, use absorbDelay.

NU — Approximation orders for the input channel

scalar | vector | Inf

Approximation orders for the input channel, specified as

• A scalar, to use the same approximation order across all the inputs.

• A vector, to specify individual approximation order values per input. You can use Inf for specific inputs to prevent approximation of corresponding delays.

NY — Approximation orders for the output channel

scalar | vector | Inf

Approximation orders for the output channel, specified as

• A scalar, to use the same approximation order across all the outputs.

• A vector, to specify individual approximation order values per output. You can use Inf for specific outputs to prevent approximation of corresponding delays.

NINT — Approximation orders for I/O delay or output delay

scalar | vector | Inf

Approximation orders for I/O delay (transfer functions or zero-pole-gain models) or internal delay (state-space models), specified as

• A scalar, to use the same approximation order across all the I/O or internal delays.

• A vector, to specify individual approximation order values per I/O or internal delay. You can use Inf for specific I/Os to prevent approximation of corresponding delays.

Output Arguments

num — Numerator coefficients of delay-free transfer function

row vector

Numerator coefficients of delay-free transfer function, returned as a row vector.

den — Denominator coefficients of delay-free transfer function

row vector

Denominator coefficients of delay-free transfer function, returned as a row vector.

sysx — Padé approximated system

model object

Padé approximated system, returned as a model object of the same type as sys.

Limitations

• Padé approximation is valid only at low frequencies and provides better frequency-domain approximation than time-domain approximation. Therefore, compare the true and approximate responses to choose the right approximation order and check the approximation validity.

• High-order Padé approximations produce transfer functions with clustered poles. Because such pole configurations tend to be very sensitive to perturbations, avoid Padé approximations with order N>10.

References

[1] Golub, Gene H., and Charles F. Van Loan. Matrix Computations. 2nd ed. Johns Hopkins Series in the Mathematical Sciences 3. Baltimore, Md: Johns Hopkins University Press, 1989. pp. 557-558.

Version History

Introduced before R2006a