Short answer def invert_permutation(p): “””Return an array s with which np.array_equal(arr[p][s], arr) is True. The array_like argument p must be some permutation of 0, 1, …, len(p)-1. “”” p = np.asanyarray(p) # in case p is a tuple, etc. s = np.empty_like(p) s[p] = np.arange(p.size) return s Sorting is an overkill here. This is just … Read more
I usually use EYE for that: A = magic(4) A(logical(eye(size(A)))) = 99 A = 99 2 3 13 5 99 10 8 9 7 99 12 4 14 15 99 Alternatively, you can just create the list of linear indices, since from one diagonal element to the next, it takes nRows+1 steps: [nRows,nCols] = size(A); … Read more
I thought it would be useful to actually time some of the solutions presented here on a larger sample input. For this input and on my machine, I find Cardstdani’s approach to be the fastest, followed by the numpy isin() approach. Setup 1 import random list_1 = [random.randint(1, 10_000) for i in range(100_000)] list_2 = … Read more
AVX2 + BMI2. See my other answer for AVX512. (Update: saved a pdep in 64bit builds.) We can use AVX2 vpermps (_mm256_permutevar8x32_ps) (or the integer equivalent, vpermd) to do a lane-crossing variable-shuffle. We can generate masks on the fly, since BMI2 pext (Parallel Bits Extract) provides us with a bitwise version of the operation we … Read more
Approach #1 Here’s a vectorized approach – m,n,r = volume.shape x,y,z = np.mgrid[0:m,0:n,0:r] X = x – roi[0] Y = y – roi[1] Z = z – roi[2] mask = X**2 + Y**2 + Z**2 < radius**2 Possible improvement : We can probably speedup the last step with numexpr module – import numexpr as ne … Read more
You can just use np.mean directly: >>> np.mean([a, b, c], axis=0) array([ 30., 20., 30.])
I can, of course, only speculate. However when I run your test with the JIT compiler enabled vs disabled, I get the following results: % with JIT no JIT 0.1677 0.0011 %# init 0.0974 0.0936 %# #1 I added an assigment before this line to avoid issues with deferring 0.4005 0.4028 %# #2 0.4047 0.4005 … Read more
I think I have finally cracked it! Here’s a vectorized version of numpy_ewma function that’s claimed to be producing the correct results from @RaduS’s post – def numpy_ewma_vectorized(data, window): alpha = 2 /(window + 1.0) alpha_rev = 1-alpha scale = 1/alpha_rev n = data.shape[0] r = np.arange(n) scale_arr = scale**r offset = data[0]*alpha_rev**(r+1) pw0 = … Read more
np.vectorize is just a convenience function. It doesn’t actually make code run any faster. If it isn’t convenient to use np.vectorize, simply write your own function that works as you wish. The purpose of np.vectorize is to transform functions which are not numpy-aware (e.g. take floats as input and return floats as output) into functions … Read more