## Documentation Center |

Replace time delays by poles at *z* =
0 or phase shift

`sysnd = absorbDelay(sysd)[sysnd,G]
= absorbDelay(sysd)`

` sysnd = absorbDelay(sysd)` absorbs
all time delays of the dynamic
system model

For discrete-time models (other than frequency response data
models), a delay of `k` sampling periods is replaced
by `k` poles at *z* = 0. For continuous-time
models (other than frequency response data models), time delays have
no exact representation with a finite number of poles and zeros. Therefore,
use `pade` to compute a rational
approximation of the time delay.

For frequency response data models in both continuous and discrete
time, `absorbDelay` absorbs all time delays into
the frequency response data as a phase shift.

`[ sysnd,G]
= absorbDelay(sysd)` returns the matrix

Create a discrete-time transfer function that has a time delay
and absorb the time delay into the system dynamics as poles at *z* =
0.

z = tf('z',-1); sysd = (-.4*z -.1)/(z^2 + 1.05*z + .08); sysd.InputDelay = 3

These commands produce the result:

Transfer function: -0.4 z - 0.1 z^(-3) * ------------------- z^2 + 1.05 z + 0.08 Sampling time: unspecified

The display of `sysd` represents the `InputDelay` as
a factor of `z^(-3)`, separate from the system poles
that appear in the transfer function denominator.

Absorb the delay into the system dynamics.

sysnd = absorbDelay(sysd)

The display of `sysnd` shows that the factor
of `z^(-3)` has been absorbed as additional poles
in the denominator.

Transfer function: -0.4 z - 0.1 ------------------------- z^5 + 1.05 z^4 + 0.08 z^3 Sampling time: unspecified

Additionally, `sysnd` has no input delay:

sysnd.InputDelay

ans = 0

Convert "nk" into regular coefficients of a polynomial model.

Consider the discrete-time polynomial model:

m = idpoly(1,[0 0 0 2 3]);

The value of the B polynomial, m.b, has 3 leading zeros. Two of these zeros are treated as input-output delays. Consequently:

sys = tf(m)

creates a transfer function such that the numerator is [0 2 3] and the IO delay is 2. In order to treat the leading zeros as regular B coefficients, use absorbDelay:

m2 = absorbDelay(m); sys2 = tf(m2);

`sys2's` numerator is `[0 0 0 2 3]` and `IO` delay
is `0`. The model `m2` treats the
leading zeros as regular coefficients by freeing their values. `m2.Structure.b.Free(1:2)` is `TRUE` while
`m.Structure.b.Free(1:2)` is `FALSE`.

`hasdelay` | `pade` | `totaldelay`

Was this topic helpful?