(In)homogeneous Poisson processes as a unique type and so on...

[jucheval]

Hi,

For now, only homogeneous Poisson processes (HPP) are implemented. A natural way to implement inhomogeneous Poisson processes (IPP) would be to make a new type InhomogeneousPoissonProcess.

However, I am considering the following design. Add 2 new "types": ConstantFunction and CustomFunction. Then, we see:

• HPP with mark type M as PoissonProcess{ConstantFunction, M},
• IPP with mark type M as PoissonProcess{CustomFunction, M}.

This may seem overkilling at first sight, but I think it would be very convenient for Hawkes processes for instance where the simulation and fitting are really different whether:

• the link function is linear or non-linear,
• the kernel function is exponential, piecewise constant, Erlang or custom.
  Here, I think that creating a new type (like the InhomogeneousPoissonProcess proposed above) for each case can be overwhelming.

What do you think of that ?

[jucheval]

@gdalle: I guess it is the good way to notify you of the Issue.

[gdalle]

I would rather recommend implementing a first batch of Hawkes processes before trying to abstract away the interface. Besides the terminology issue (is a Hawkes process really an inhomogeneous Poisson process?), it may turn out that you need to dispatch on something different. If you do something like

struct HawkesProcess{L,K}
    link::L
    kernel::K
end

you may want to dispatch on things like HawkesProcess{:linear} or HawkesProcess{L,typeof(exp)}

[jucheval]

1. You are right: a Hawkes process is not an IPP. I considered both as (independent) exposition examples in my first message.
2. I do not understand at all your comment on dispatching. Sorry... Do you mean that we may have some ambiguity ?

[gdalle]

If we stick to the simple PoissonProcess example, you do not need to define two types ConstantFunction and CustomFunction for dispatch. You could get away with just ConstantFunction, because if you define a dispatch structure like

simulate(pp::PoissonProcess{<:ConstantFunction}, ...)
simulate(pp::PoissonProcess, ...)

then everything which is not a homogeneous process will fall into case 2.
Note that in this specific scenario, you don't even need a new wrapper for constant functions, you could just use Base.Returns.

[jucheval]

Okay. I think I get the idea.

[rsenne]

Closing this as this discussion is now outdated as of #65 and #59.