CODEWITHSUNDEEP
pythonarrayssum
user10016906
user10016906

Reputation:

Coding an iterated sum of sums in python

For alpha and k fixed integers with i < k also fixed, I am trying to encode a sum of the form

where all the x and y variables are known beforehand. (this is essentially the alpha coordinate of a big iterated matrix-vector multiplication)

For a normal sum varying over one index I usually create a 1d array A and set A[i] equal to the i indexed entry of the sum then use sum(A), but in the above instance the entries of the innermost sum depend on the indices in the previous sum, which in turn depend on the indices in the sum before that, all the way back out to the first sum which prevents me using this tact in a straightforward manner.

I tried making a 2D array B of appropriate length and width and setting the 0 row to be the entries in the innermost sum, then the 1 row as the entries in the next sum times sum(np.transpose(B),0) and so on, but the value of the first sum (of row 0) needs to vary with each entry in row 1 since that sum still has indices dependent on our position in row 1, so on and so forth all the way up to sum k-i.

A sum which allows for a 'variable' filled in by each position of the array it's summing through would thusly do the trick, but I can't find anything along these lines in numpy and my attempts to hack one together have thus far failed -- my intuition says there is a solution that involves summing along the axes of a k-i dimensional array, but I haven't been able to make this precise yet. Any assistance is greatly appreciated.

Upvotes: 0

Views: 565

Answers (2)

sehigle
sehigle

Reputation: 332

One simple attempt to hard-code something like this would be:

for j0 in range(0,n0):
    for j1 in range(0,n1):
        ....

Edit: (a vectorized version)

You could do something like this: (I didn't test it)

temp = np.ones(n[k-i])
for j in range(0,k-i):
    temp = x[:n[k-i-1-j],:n[k-i-j]].T@(y[:n[k-i-j]]*temp)
result = x[alpha,:n[0]]@(y[:n[0]]*temp)

The basic idea is that you try to press it into a matrix-vector form. (note that this is python3 syntax)

Edit: You should note that you need to change the "k-1" to where the innermost sum is (I just did it for all sums up to index k-i)

Upvotes: 1

CrepeGoat
CrepeGoat

Reputation: 2515

This is 95% identical to @sehigle's answer, but includes a generic N vector:

def nested_sum(XX, Y, N, alpha):
    intermediate = np.ones(N[-1], dtype=XX.dtype)

    for n1, n2 in zip(N[-2::-1], N[:0:-1]):
        intermediate = np.sum(XX[:n1, :n2] * Y[:n2] * intermediate, axis=1)

    return np.sum(XX[alpha, :N[0]] * Y[:N[0]] * intermediate)

Similarly, I have no knowledge of the expression, so I'm not sure how to build appropriate tests. But it runs :\

Upvotes: 1

Related Questions