Accelerating the pace of engineering and science

# absorbDelay

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

## Syntax

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

## Description

sysnd = absorbDelay(sysd) absorbs all time delays of the dynamic system model 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.

[sysnd,G] = absorbDelay(sysd) returns the matrix G that maps the initial states of the ss model sysd to the initial states of the sysnd.

## Examples

### Example 1

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```

### Example 2

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.