Heaviside step

[llandsmeer]

This PR adds the Heaviside step function to Arbor's iexpr, needed for some inhomogeneous density mechanism like the ones in this model. Arguable, one could also use segment groups but this makes automated translation of an existing model using NeuroML's H() much much easier.

The implementation returns

def step(x):
    if x > 0:
        return 1
    else:
        return 0

which makes sense to me, but does not have to be the semantics that we follow.

For example the NeuroML/LEMS implementation uses the half-maximum convention

ret = 0.5*(Math.signum(arg)+1.);

which has H(0.0) == 0.5.

[thorstenhater]

Nice work, thanks for making NML2 a bit easier. A question on the design, though:
If this is specifically for the support of NML2 semantics, why not implement it the
same way (or add an alternative say hstep, which has that (admittedly weird) behaviour)?

[llandsmeer]

Because I wasn't sure if the Math.signum implementation was 'the standard' or just the easiest way to get a step function in java. I couldn't find the official definition. The python LEMS implementation also has the half-maximum convention explicitly spelled out though, which makes it more official I think?

https://github.com/LEMS/pylems/blob/1180c4fa58a8e2c1b23a284fd7088c3b2e398f00/lems/sim/build.py#L773

        elif func == "H":

            def heaviside_step(x):
                if x < 0:
                    return 0
                elif x > 0:
                    return 1
                else:
                    return 0.5

            return "heaviside_step"

The LEMS paper also mentions

The LEMS language was developed in parallel to the initial reference implementation jLEMS (source code at https://github.com/LEMS/jLEMS), and the serialization of LEMS in XML followed closely the internal classes used in jLEMS for specifying the model. Documentation of all of the elements in LEMS can be found here: http://lems.github.io/LEMS/elements.html. This is automatically generated from documentation in the jLEMS source code.

Which I guess makes the Java version the official standard..

I'll change it to the half-maxmimum convention

[thorstenhater]

The problem is that IEEE745 float/doubles are signed, so we actually have ±0. Java might be different. Let's just define
hw-step or similar to delineate from a proper heaviside.

[llandsmeer]

The problem is that IEEE745 float/doubles are signed, so we actually have ±0. Java might be different. Let's just define hw-step or similar to delineate from a proper heaviside.

How would half-maximum heaviside deviate here from binary heaviside w.r.t. -0?

Something like this:

hm_step(-0) = 0.5
hm_step(+0) = 0.5

bin_step(-0) = 0
bin_step(+0) = 1

or

hm_step(-0) = 0
hm_step(+0) = 0.5

bin_step(-0) = 1
bin_step(+0) = 1

?

Not that I hope that any production code every relies on this behaviour :)

[boeschf]

The current implementation is behaving like the former variant (-0 and +0 are treated equally), which in my book is a good thing.