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

`sysnd = absorbDelay(sysd)`

[sysnd,G]
= absorbDelay(sysd)

absorbs
all time delays of the dynamic
system model `sysnd`

= absorbDelay(`sysd`

)`sysd`

into the system
dynamics or the frequency response data.

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.

`[`

returns the matrix `sysnd`

,`G`

]
= absorbDelay(`sysd`

)`G`

that
maps the initial states of the `ss`

model `sysd`

to
the initial states of the `sysnd`

.

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 Sample 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 Sample 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?