gauss | JavaScript statistics , analytics , and data library | Analytics library

I believe you are running into this problem because curve_fit is also testing non-integer values of n, in which case your function gauss returns complex values when x.

I believe it would be easier to brute-force your way through every integer n and find the best parameters sig,c,x_o for each n. For example, if you consider n = 0,1,2,... up to perhaps 50, there are very few options for n, and brute forcing is actually a decent method. Looking at your data, it would be even better to only consider n as a multiple of 2 (unless your other data looks like n could be an odd integer).

Also, you should probably introduce some bounds for the other parameters, like it would be good to have sig>0, and you can safely set c>0 (that is, if all of your data looks like the minimal data you included in your question).

Here is what I did:

You can add if __name__ == "__main__": in your main.py file.

For example:

You may obtain standard errors from local coefficients running the function GWmodel::ggwr.basic. Function spgwr::ggwr() returns coefficients but no standard errors.

First of all, the implementation of rand is often pretty slow and using a slow division by RAND_MAX with a float cast is not going to help either. As a result, it is not surprising that the gauss and gaussbm implementations (which call at least rand twice) are actually slower than gaussInv (which call rand once).

Moreover, gauss is slow also because of the bad predictability of the while loop (processors are often faster on predictable loops and conditionals), and gaussbm is slow also because of the expensive cos/sin trigonometric function.

While gaussInv should be faster than the two others, it can be still improved. One way it to use vectorization and a custom optimized random function. Indeed, most processors can work on many floating-point at a time thanks to SIMD instruction and this function can makes use of them (although this is not straightforward). Most mainstream x86-64 processors can work on 8 floats in a row (using AVX/AVX2) and few recent processors can even compute up to 16 floats in a row (using AVX-512). Note that gaussbm could be vectorized too.

For scalar implementations, lookup tables can be used to speed up the computation although the throughput of the fastest scalar implementation will likely be significantly less than the one of any optimized vectorised implementation on modern mainstream processors.

You theoreticaly can compute the 3d-gaussian convolution using three 2d-convolutions, but that would mean you have to reduce the size of the 2d-kernel, as you're effectively convolving in each direction twice.

But computationally more efficient (and what you usually want) is a separation into 1d-kernels. I changed the second part of your function to implement this. (And I must say I really liked your permutation-based appraoch!) Since you're using a 3d volume you can't really use the conv2d or conv1d functions well, so the best thing is really just using conv3d even if you're just computing 1d-convolutions.

Note that allclose uses a threshold of 1e-8 which we do not reach with this method, probably due to cancellation errors.

You can take a look at pointer-events.

ex

You can generate the whole array with np.random then fill the nan's with loc:

Here is the working code based on your attempt:

It's expecting "2-tuple of array_like, optional" so that looks like: