Many built-in operations like sum and prod are already able to operate across rows or columns, so you may be able to refactor the function you are applying to take advantage of this. If that’s not a viable option, one way to do it is to collect the rows or columns into cells using mat2cell … Read more
Here’s an approach using broadcasting – def create_ranges(start, stop, N, endpoint=True): if endpoint==1: divisor = N-1 else: divisor = N steps = (1.0/divisor) * (stop – start) return steps[:,None]*np.arange(N) + start[:,None] Sample run – In [22]: # Setup start, stop for each row and no. of elems in each row …: start = np.array([1,4,2]) …: … Read more
Straightforward way to do that is: import numpy as np a=np.array([[1,2,3],[3,4,5]]) b=np.array([[1,2,3],[1,2,3]]) np.sum(a*b, axis=1) which avoids the python loop and is faster in cases like: def npsumdot(x, y): return np.sum(x*y, axis=1) def loopdot(x, y): result = np.empty((x.shape[0])) for i in range(x.shape[0]): result[i] = np.dot(x[i], y[i]) return result timeit npsumdot(np.random.rand(500000,50),np.random.rand(500000,50)) # 1 loops, best of 3: … Read more
This looks normal; adding numbers in a different order produces different rounding in the temporaries. FP math is not associative; optimizing as if it is will change the results.1 Is Floating point addition and multiplication associative? / Are floating point operations in C associative? The amount of change depends on the data. Differences only in … Read more
Two approaches you can use here. Approach 1: y = [1; 3; 2; 1; 3]; yvec = zeros(numel(y),3); yvec(sub2ind(size(yvec),1:numel(y),y’))=1 Approach 2 (One-liner): yvec = bsxfun(@eq, 1:3,y)
So, basically, you want your code to run faster. JNI is the answer. I know you said it didn’t work for you, but let me show you that you are wrong. Here’s Dot.java: import java.nio.FloatBuffer; import org.bytedeco.javacpp.*; import org.bytedeco.javacpp.annotation.*; @Platform(include = “Dot.h”, compiler = “fastfpu”) public class Dot { static { Loader.load(); } static float[] … Read more
Just use mapply: Start = c(1,10,20) Finish = c(9,19,30) mapply(“:”, Start, Finish) ## [[1]] ## [1] 1 2 3 4 5 6 7 8 9 ## ## [[2]] ## [1] 10 11 12 13 14 15 16 17 18 19 ## ## [[3]] ## [1] 20 21 22 23 24 25 26 27 28 29 … Read more
We can add each row some offset as compared to the previous row. We would use the same offset for both arrays. The idea is to use np.searchsorted on flattened version of input arrays thereafter and thus each row from b would be restricted to find sorted positions in the corresponding row in a. Additionally, … Read more
Well that’s basically what does np.bincount does with 1D arrays. But, we need to use it on each row iteratively (thinking of it simply). To make it vectorized, we could offset each row by that max number. The idea is to have different bins for each row such that they are not affected by other … Read more
You might think this would work: import numpy as np n = len(Tm) t = np.empty(n) t[0] = 0 # or whatever the initial condition is t[1:] = Tm[1:] + (t[0:n-1] – Tm[1:])**(-tau[1:]) but it doesn’t: you can’t actually do recursion in numpy this way (since numpy calculates the whole RHS and then assigns it … Read more