Hello everyone,

I need some help with simulating a renewal equation, as described in this paper. Here’s a minimal example of the equation I’m working with:

```
x(t) = a * x(t - 1) + b * x(t - √2)
```

I want to solve this using a “Method of Steps”-like approach, ideally leveraging the full capabilities of the `DifferentialEquations.jl`

toolbox, potentially with discontinuity tracking, error control,… . However, since the derivative is not provided, I am currently stuck.

I know that this equation could be viewed as a pure neutral equation, meaning we are essentially simulating its integral form:

```
ϵ dx/dt(t) = a * dx/dt(t - 1) + b * dx/dt(t - √2)
```

However, this approach also presents challenges when it comes to tracking discontinuities.

Alternatively, the equation could be interpreted as an algebraic equation (zero mass matrix or through singular perturbation):

```
0 = a * x(t - 1) + b * x(t - √2) - x(t)
```

But since I have the explicit form, this seems inefficient.

One might suggest substituting the explicit algebraic equation back (as many times we land on the given history function), but this could lead to an exponentially growing number of substitutions in case of long simulations.

### Potential Solutions:

**Wrap something around**`DifferentialEquations.jl`

.**Integrate the explicit solution into the ecosystem.**

The second solution would be the test, but I could have problems with the not-directly-available derivatives when we use the “free” interpolation of the solution object (necessary at a later step). We could make linear interpolation between the saved points, but it would lead to poor performance.

Any guidance or recommendations on how to proceed would be greatly appreciated!

Thanks,

Daniel

**P.S. 1:** My goal is to simulate the system directly and later perform a bifurcation analysis.

**P.S. 2:** The minimal example provided might eventually include distributed delays, discontinuities, and nonlinearities.

**P.S. 3:** An another related problem I’d like to solve is:

```
x(t) = a * x(t - 1) + y(t) # explicit renewal part
dy/dt = -y(t) + x(t - 1) # a DDE part
```

with discontinuities in the history functions and callbacks in the process (e.g.: collision at x=1)