如何在时间序列数据中找到最大增长率？

Question

I would like to know the algorithm of finding the max growth rate in a given time period.

Suppose we have eight(N) data points as following,

list_x = [84,59,52,71,62,82,45,50]
def find_max(list_x):
   # return the L index, H index, ratio
   # take list_x as an example, L index: 3(52), H index: 6(82), ratio: 82/52 
   # should return (3, 6, 1.57)
   return L,H,dy/dx

A brute way would be going through O(N*N), store the ratio dicts, then sorting by ratio. Any efficient algorithms? thanks

Answer 1

As I mentioned in a comment it looks like you are looking for H/L instead of dy/dh since your expected result is (3, 6, 1.57) . Assuming you actually want to do H/L then you can try the following:

def max_result(arr):
    max_growth, cur_min, cur_min_idx = float('-inf'), float('inf'), -1
    res_l = res_h = float('-inf')
    for i, val in enumerate(arr):
        if val / cur_min > max_growth:
            max_growth = val / cur_min
            res_l, res_h = cur_min_idx, i
        if val < cur_min:
            cur_min, cur_min_idx = val, i
    return res_l + 1, res_h + 1, round(max_growth, 2)

The complexity here is O(N)

Answer 2

Push the nested loops to C using Numpy.

import numpy as np

a = np.array([84,59,52,71,62,82,45,50])

Calculate the difference between each point and all other points

b = (a - a[:,None])

Calculate dy/dx for all those differences. This assumes the x-values are contiguous and evenly spaced.

d = np.arange(a.shape[0], dtype=float)
d = d-d[:,None]
d[d==0] = .00001
c  = b / d

Find the indices of the maximum dy/dx and use them to get the values that produced it.

max_dydx = np.triu(c).max()
indices = np.where(np.triu(c) == max_dydx)
values = a[np.concatenate(indices)]
print(indices, values)

---

>>>
(array([4], dtype=int64), array([5], dtype=int64)) [62 82]

---

Intermediate arrays - values reflect across the diagonal.

>>> print(b.round(1))
[[  0 -25 -32 -13 -22  -2 -39 -34]
 [ 25   0  -7  12   3  23 -14  -9]
 [ 32   7   0  19  10  30  -7  -2]
 [ 13 -12 -19   0  -9  11 -26 -21]
 [ 22  -3 -10   9   0  20 -17 -12]
 [  2 -23 -30 -11 -20   0 -37 -32]
 [ 39  14   7  26  17  37   0   5]
 [ 34   9   2  21  12  32  -5   0]]
>>> print(d.round(1))
[[ 0.  1.  2.  3.  4.  5.  6.  7.]
 [-1.  0.  1.  2.  3.  4.  5.  6.]
 [-2. -1.  0.  1.  2.  3.  4.  5.]
 [-3. -2. -1.  0.  1.  2.  3.  4.]
 [-4. -3. -2. -1.  0.  1.  2.  3.]
 [-5. -4. -3. -2. -1.  0.  1.  2.]
 [-6. -5. -4. -3. -2. -1.  0.  1.]
 [-7. -6. -5. -4. -3. -2. -1.  0.]]
>>> print(c.round(1))
[[  0.  -25.  -16.   -4.3  -5.5  -0.4  -6.5  -4.9]
 [-25.    0.   -7.    6.    1.    5.8  -2.8  -1.5]
 [-16.   -7.    0.   19.    5.   10.   -1.8  -0.4]
 [ -4.3   6.   19.    0.   -9.    5.5  -8.7  -5.2]
 [ -5.5   1.    5.   -9.    0.   20.   -8.5  -4. ]
 [ -0.4   5.8  10.    5.5  20.    0.  -37.  -16. ]
 [ -6.5  -2.8  -1.8  -8.7  -8.5 -37.    0.    5. ]
 [ -4.9  -1.5  -0.4  -5.2  -4.  -16.    5.    0. ]]