The integro-differential equations I need to solve are of this form: http://mathb.in/30204. While I already have written a solver for a simple test problem (s. code below), the type of equation shown in the link above can become very costly because of matrix multiplications. In short, it would be great to have some input on how to implement this efficiently with DifferentialEquations.jl.

When building up the ‘memory integral’ on the right-hand side, it would be most efficient to save the value of the integral for the previous time steps, then perform one matrix multiplication for the next time step and add that to the existing sum over the past. While it is kind of obvious how to code this from scratch, I cannot see how to achieve a similar thing either as an `ODEProblem`

or a `DDEProblem`

.

Test problem: https://en.wikipedia.org/wiki/Integro-differential_equation

```
const alpha = 2; const beta = 5;
const u_0 = 0.0
const t_0 = 0.0
const T = 5.0
const n = 1000
const lags = range(delta_t, length=n, stop=(T-t_0)*(1-1/n))
# left Riemann sum
function f(du, u, h, p, t)
du[1] = 1 - alpha*u[1] - beta*((T-t_0)/n)*sum([h(p, t-tau)[1] for tau in lags])
end
h(p, t) = zeros(1)
tspan = (0.0, T)
u0 = [u_0]
prob = DDEProblem(f, u0, h, tspan)
algo = MethodOfSteps(Tsit5())
prob = DDEProblem(f, u0, hist, tspan)
```