gammaln | Natural logarithm of the gamma function | Natural Language Processing library

For real x you can use the series expansion of log(Ei(x)) for x → ∞ (see here) which is highly accurate for large x.

From some quick experimentation, 18 terms is enough for full float precision when x >= 50 (and that's around where scipy starts losing full precision). Also the series expansion is really nice, the coefficients being the factorial numbers, so we can use precise evaluation without catastrophic cancellation:

Looking at the model, the background estimate shouldn't be zero, so add an epsilon of 1e-7 to it and then an 1% background uncertainty. Though the issue here is that reasonable intervals for signal strength are between μ ∈ [0,10]. If your model is such that you aren't sensitive to a signal strength in this range then you should test a new signal model which is the original signal scaled by some scale factor.

For visualization purposes let's extend the environment a bit

As an example, I tried 1 / x for the integration between 1 and alpha to retrieve the target integral 2.0. This

Downgrading to scipy==1.1.0 solves the issue

You are computing np.log(LAM = beats = [0]) in poissonNegLogLikelihood() and log(0) is -inf. Therefore, it seems to me that your initial guess betas is the problem. You should test with adequate values.

It can be quite some work to reimplement some often used functions, not only to reach the performance, but also to get a well defined level of precision. So the direct way would be to simply wrap a working implementation.

In case of gammaln scipy- calls a C-implemntation of this function. Therefore the speed of the scipy-implementation also depends on the compiler and compilerflags used when compiling the scipy dependencies.

It is also not very suprising that the performance results for one value can differ quite a lot from the results of larger arrays. In the first case the calling overhead (including type conversions, input checking,...) dominates, in the second case the performance of the implementation gets more and more important.

Improving your implementation

• Write explicit loops. In Numba vectorized operations are expanded to loops and after that Numba tries to join the loops. It is often better to write out and join this loops manually.
• Think of the differences of basic arithmetic implementations. Python always checks for a division by 0 and raises an exception in such a case, which is very costly. Numba also uses this behaviour by default, but you can also switch to Numpy-error checking. In this case a division by 0 results in NaN. The way NaN and Inf -0/+0 is handled in further calculations is also influenced by the fast-math flag.

Code

The runtime of your function will scale linearly (up to some constant overhead) with the number of iterations. So getting the number of iterations down is key to speeding up the algorithm. Whilst computing the HARMONIC_10MIL beforehand is a smart idea, it actually leads to worse accuracy when you truncate the series; computing only part of the series turns out to give higher accuracy.

The code below is a modified version of the code posted above (although using cython instead of numba).

I had the same problem while running the psignifit function with my 2AFC data.

The reason was very simple, the psignifit function causes this error message if you try to process data exceeding the 0 to 1 limits, for example 1.0000000001

You were right, it was some odd numeric reason.

Change this line:

total += (-1)**i * comb(m, i, exact=True) * ((m-i)/k)**n

to this:

total += (-1)**i * comb(m, i, exact=True) * ((m-i)**n)/(k**n)

For some reason, if you force a different operation order, things come out nicely.

You might have to spend some more time figuring out how to modify your "log'd" version, but given that the change above fixes things, you might just want to discard the "log'd" version altogether.

Hope it helps!