I was curious if there was a quick way of calculating the cumulative product sum for a given array in Python. I understand that numpy has both the cumsum and cumprod functions, but neither seems to work in conjunction with my case. My iterative sequence is as follows, where t is a time index:
X_{t+1} = X_{t} * (B_{t+1} - B_{t}) + X_t
Any suggestions would be greatly appreciated.
In this solution, I will assume the vector B is known. The equation for X can be simplified as follows
X_(t+1) = (B_(t+1) - B_t) X_t + X_t
X_(t+1) = ((B_(t+1) - B_t) + 1) X_t
let C = B[1:] - B[:-1] + 1.
Now the dynamic equation is
X_(t+1) = C_t X_t
Observe the behaviour of the equation
X_1 = C_0 X_0
X_2 = C_1 C_0 X_0
X_3 = C_2 C_1 C_0 X_0
From the pattern above, we get
X_n = C_(n-1) ... C_0 X_0
This means, if you are just after a particular state, you do not need to explicitly compute every preceding state.
To get the product of elements in a numpy array, simply use numpy.prod. The snippet below shows how to compute X for a given point and how to compute X at all values for t
import numpy as np
# provide for B and X_0 yourself.
C = B[1:] - B[:-1] + 1
X = np.cumprod(C) * X_0 # compute the entire X vector at once.
X_5 = np.prod(C[:5]) * X_0 # compute X_5 only
That's it! no explicit looping or recursion.
C = B[1:] - B[:-1] + 1. B[:-2] will drop last 2 elementsTry this. Since X_2, X_3, .... should be calculated in each time, loop should be used, but B_diff ([B_2-B_1, B_3-B_2, ...]) is calculated efficiently in advances.
def make_X(initial_X, B):
B_diff = B[1:] - B[:-1] + 1
X = [initial_X]
for t in range(len(B_diff)):
next_X = B_diff[t] * X[-1]
X.append(next_X)
return X
# Test
make_X(1, np.array([1, 2, 3, 4]))
Ultimately decided to work with a numpy apply custom function, since I need to use this across a matrix:
# for calculating the series
def myFunc(arr:np.array, initial:int, size:int):
temp = initial
new_arr = [0]*size
for i in range(size):
new_arr[i] = temp + (temp * arr[i])
temp += temp * arr[i]
return np.array(new_arr)
# for implementing it across my matrix
np.apply_along_axis(myFunc, 0, arr, initial, size)
apply_along_axis may be handy in this case, but it isn't a speed improvement (over a more explicit loop).