Merton model

[JADekker]

In order to work with e.g. the Merton model, some way of dealing with jump processes is necessary; is it possible to add e.g. JumpProcesses.jl to the dependencies? I think something like the following (untested) could then be used to specify the dynamics under the Merton model:

function LogGBMJProblem(μ, σ, λ, μⱼ, σⱼ, u0, tspan; seed = UInt64(0), kwargs...)
    f = function (u, p, t)
        return @. μ - 0.5 * σ^2  # Drift of log(S_t)
    end
    g = function (u, p, t)
        return @. σ  # Constant diffusion for log(S_t)
    end

    J = LogNormal(μⱼ, σⱼ)

    affect! = function (integrator)
        @. integrator.u[1] *= Distributions.rand(J)
        nothing
    end

    const_jump = ConstantRateJump(λ, affect!)

    noise = WienerProcess(tspan[1], 0.0)

    sde_f = SDEFunction(f, g)
    sde_prob = SDEProblem{false}(
        sde_f,
        u0,
        (tspan[1], tspan[2]),
        noise = noise,
        seed = seed,
        kwargs...,
    )
    return JumpProblem(sde_prob, Direct(), const_jump)
end

[aleCombi]

Jumps are indeed a natural next step, in this case I think the characteristic function is also known, so a good benchmark can be done using Carr Madan.
I like this stuff so I want to start with the Carr Madan solver soon.
I updated the roadmap accordingly (https://alecombi.github.io/Hedgehog.jl/stable/derivatives_pricing_roadmap/).

[JADekker]

Jumps are indeed a natural next step, in this case I think the characteristic function is also known, so a good benchmark can be done using Carr Madan.
I like this stuff so I want to start with the Carr Madan solver soon.
I updated the roadmap accordingly (https://alecombi.github.io/Hedgehog.jl/stable/derivatives_pricing_roadmap/).

That should be the case, as it is an affine jump-diffusion. Note that the original Merton paper also has a series solution to the problem, which provides another nice reference point. Furthermore, you can do exact simulation both for the end-points and for the process evaluated at intermediate time-points (draw from Poi(lambda * dt) for the number of jumps in an interval, draw normal random variables for the jumps and then scale them appropriately for the number of jumps). If fast exact simulation becomes a feature in Hedgehog, I'd be happy to add it for this model, just let me know!