# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

# dde23

Solve delay differential equations (DDEs) with constant delays

## Syntax

```sol = dde23(ddefun,lags,history,tspan) sol = dde23(ddefun,lags,history,tspan,options) ```

## Arguments

 `ddefun` Function handle that evaluates the right side of the differential equations ${y}^{\prime }\left(t\right)=f\left(t,y\left(t\right),y\left(t-{\tau }_{1}\right),...,y\left(t-{\tau }_{k}\right)\right)$. The function must have the form`dydt = ddefun(t,y,Z)`where `t` corresponds to the current t, `y` is a column vector that approximates y(t), and `Z(:,j)` approximates y(t – τj) for delay τj = `lags(j)`. The output is a column vector corresponding to $f\left(t,y\left(t\right),y\left(t-{\tau }_{1}\right),...,y\left(t-{\tau }_{k}\right)\right)$. `lags` Vector of constant, positive delays τ1, ..., τk. `history` Specify `history` in one of three ways:A function of t such that ```y = history(t)``` returns the solution y(t) for t ≤ t0 as a column vectorA constant column vector, if y(t) is constantThe solution `sol` from a previous integration, if this call continues that integration `tspan` Interval of integration from `t0=tspan(1)` to `tf=tspan(end)` with ```t0 < tf```. `options` Optional integration argument. A structure you create using the `ddeset` function. See `ddeset` for details.

## Description

`sol = dde23(ddefun,lags,history,tspan)` integrates the system of DDEs

${y}^{\prime }\left(t\right)=f\left(t,y\left(t\right),y\left(t-{\tau }_{1}\right),...,y\left(t-{\tau }_{k}\right)\right)$

on the interval [t0,tf], where τ1, ..., τk are constant, positive delays and t0,tf. The input argument, `ddefun`, is a function handle.

Parameterizing Functions explains how to provide additional parameters to the function `ddefun`, if necessary.

`dde23` returns the solution as a structure `sol`. Use the auxiliary function `deval` and the output `sol` to evaluate the solution at specific points `tint` in the interval `tspan = [t0,tf]`.

`yint = deval(sol,tint)`

The structure `sol` returned by `dde23` has the following fields.

 `sol.x` Mesh selected by `dde23` `sol.y` Approximation to y(x) at the mesh points in `sol.x`. `sol.yp` Approximation to y′(x) at the mesh points in `sol.x` `sol.solver` Solver name, `'dde23'`

`sol = dde23(ddefun,lags,history,tspan,options)` solves as above with default integration properties replaced by values in `options`, an argument created with `ddeset`. See `ddeset` and Types of DDEs for more information.

Commonly used options are scalar relative error tolerance `'RelTol'` (`1e-3` by default) and vector of absolute error tolerances `'AbsTol'` (all components are `1e-6` by default).

Use the `'Jumps'` option to solve problems with discontinuities in the history or solution. Set this option to a vector that contains the locations of discontinuities in the solution prior to `t0` (the history) or in coefficients of the equations at known values of t after `t0`.

Use the `'Events'` option to specify a function that `dde23` calls to find where functions $g\left(t,y\left(t\right),y\left(t-{\tau }_{1}\right),...,y\left(t-{\tau }_{k}\right)\right)$ vanish. This function must be of the form

`[value,isterminal,direction] = events(t,y,Z)`

and contain an event function for each event to be tested. For the `k`th event function in `events`:

• `value(k)` is the value of the `k`th event function.

• `isterminal(k) = 1` if you want the integration to terminate at a zero of this event function and `0` otherwise.

• `direction(k) = 0` if you want `dde23` to compute all zeros of this event function, `+1` if only zeros where the event function increases, and `-1` if only zeros where the event function decreases.

If you specify the `'Events'` option and events are detected, the output structure `sol` also includes fields:

 `sol.xe` Row vector of locations of all events, i.e., times when an event function vanished `sol.ye` Matrix whose columns are the solution values corresponding to times in `sol.xe` `sol.ie` Vector containing indices that specify which event occurred at the corresponding time in `sol.xe`

## Examples

This example solves a DDE on the interval [0, 5] with lags 1 and 0.2. The function `ddex1de` computes the delay differential equations, and `ddex1hist` computes the history for `t <= 0`.

### Note

The file, `ddex1.m`, contains the complete code for this example. To see the code in an editor, type `edit ddex1` at the command line. To run it, type `ddex1` at the command line.

`sol = dde23(@ddex1de,[1, 0.2],@ddex1hist,[0, 5]);`

This code evaluates the solution at 100 equally spaced points in the interval `[0,5]`, then plots the result.

```tint = linspace(0,5); yint = deval(sol,tint); plot(tint,yint);```

`ddex1` shows how you can code this problem using local functions. For more examples see `ddex2`.

## Algorithms

`dde23` tracks discontinuities and integrates with the explicit Runge-Kutta (2,3) pair and interpolant of `ode23`. It uses iteration to take steps longer than the lags.

## References

[1] Shampine, L.F. and S. Thompson, “Solving DDEs in MATLAB,” Applied Numerical Mathematics, Vol. 37, 2001, pp. 441-458.

[2] Kierzenka, J., L.F. Shampine, and S. Thompson, “Solving Delay Differential Equations with dde23