Summing three consecutive number when equal to or great than 0 - Python

Question

I am using numpy in Python

I have an array of numbers, for example:

arr = np.array([0.1, 1, 1.2, 0.5, -0.3, -0.2, 0.1, 0.5, 1)

If i is a position in the array, I want to create a function which creates a running sum of i and the two previous numbers, but only accumulating the number if it is equal to or greater than 0.

In other words, negative numbers in the array become equal to 0 when calculating the three number running sum.

For example, the answer I would be looking for here is

2.3, 2.7, 1.7, 0.5, 0.1, 0.6, 1.6

The new array has two elements less than the original array as the calculation can't be completed for the first two number.

Thank you !

Akshay Sehgal · Answer 1 · 2020-12-03T19:02:23.213

As Dani Mesejo answered, you can use stride tricks. You can either use clip or boolean indexing to handle the <0 elements. I have explained how stride tricks work below -

arr[arr<0]=0 sets all elements below 0 as 0
as_strided takes in the array, the expected shape of the view (7,3) and the number of strides in the respective axes, (8,8). This is the number of bytes you have to move in axis0 and axis1 respectively to access the next element. E.g. If you want to move every 2 elements, then you can set it to (16,8). This means you would move 16 bytes each time to get the element in axis0 (which is 0.1->1.2->0->0.1->.., till a shape of 7) and 8 bytes each time to get element in axis1 (which is 0.1->1->1.2, till a shape of 3)

Use this function with caution! Always use x.strides to define the strides parameter to avoid corrupting memory!

Lastly, sum this array view over axis=1 to get your rolling sum.

arr = np.array([0.1, 1, 1.2, 0.5, -0.3, -0.2, 0.1, 0.5, 1])
w = 3  #rolling window

arr[arr<0]=0

shape = arr.shape[0]-w+1, w  #Expected shape of view (7,3)
strides = arr.strides[0], arr.strides[0] #Strides (8,8) bytes
rolling = np.lib.stride_tricks.as_strided(arr, shape=shape, strides=strides)

rolling_sum = np.sum(rolling, axis=1)
rolling_sum

array([2.3, 2.7, 1.7, 0.5, 0.1, 0.6, 1.6])

Would the code above work for a cube? I have a time dimension it would be useful to keep in — amberluc, Dec 09 '20 at 16:08
you mean an higher dimensional tensor? yes. as long as you understand how `as_strided` works, you can simply get the `arr.strides` which would be a 4 element tuple for a 4D array and run the above code. You will have to define the output shape expected and the strides that need to be taken in along those axes of the output shape. — Akshay Sehgal, Dec 09 '20 at 16:09

score 1 · Answer 2 · answered Dec 03 '20 at 18:25

You could clip, roll and sum:

import numpy as np


def rolling_window(a, window):
    """Recipe from https://stackoverflow.com/q/6811183/4001592"""
    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
    strides = a.strides + (a.strides[-1],)
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)


a = np.array([0.1, 1, 1.2, 0.5, -0.3, -0.2, 0.1, 0.5, 1])

res = rolling_window(np.clip(a, 0, a.max()), 3).sum(axis=1)
print(res)

Output

[2.3 2.7 1.7 0.5 0.1 0.6 1.6]

score 1 · Answer 3 · answered Dec 03 '20 at 18:35

1

You may use np.correlate to sweep an array of 3 ones over the clipped of arr to get desired output

In [20]: np.correlate(arr.clip(0), np.ones(3), mode='valid')
Out[20]: array([2.3, 2.7, 1.7, 0.5, 0.1, 0.6, 1.6])

answered Dec 03 '20 at 18:35

Andy L.

24,909
4
17
29

score 0 · Answer 4 · answered Dec 03 '20 at 18:31

arr = np.array([0.1, 1, 1.2, 0.5, -0.3, -0.2, 0.1, 0.5, 1])

def sum_3(x):
    collector = []
    
    for i in range(len(arr)-2):            
        collector.append(sum(arr[i:i+3][arr[i:i+3]>0]))
    return collector

#output

[2.3, 2.7, 1.7, 0.5, 0.1, 0.6, 1.6]

Easiest and most comprehensible way. The collector will append the sum of the 3 consecutive numbers if their indices are True otherwise, they are all turned to 0s.

The method is not general, it is for 3 consecutives but you can adapt it.

def sum_any(x,n):
    collector = []
    for i in range(len(arr)-(n-1)):            
        collector.append(sum(arr[i:i+n][arr[i:i+n]>0]))
    return collector

score 0 · Answer 5 · answered Dec 03 '20 at 18:51

Masked arrays and view_as_windows (which uses numpy strides under the hood) are built for this purpose:

from skimage.util import view_as_windows
arr = view_as_windows(arr, 3)
arr2 = np.ma.masked_array(arr, arr<0).sum(-1)

output:

[2.3 2.7 1.7 0.5 0.1 0.6 1.6]

Summing three consecutive number when equal to or great than 0 - Python

5 Answers5