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

我想知道在给定时间段内求最大增长率的算法

假设我们有八（N）个数据点，如下所示

一种简单的方法是通过O（N*N），存储比率dicts，然后按比率排序。

---

有什么有效的算法吗？谢谢

正如我在一篇评论中提到的，看起来您正在寻找的是

H/L

而不是

dy/dh

，因为您的预期结果是

（3,6,1.57）

。假设您确实想要执行

H/L

，则可以尝试以下操作：

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)

def max_结果（arr）：
最大增长，cur_min，cur_min_idx=float（'-inf'），float（'inf'），-1
res_l=res_h=float（'-inf'）
对于i，枚举中的val（arr）：
如果val/cur\u min>max\u growth：
最大增长=瓦尔/电流最小值
res_l，res_h=cur_min_idx，i
如果val

---

这里的复杂性是

O（N）

使用Numpy将嵌套循环推送到C

import numpy as np

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

计算每个点与所有其他点之间的差值

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

计算所有这些差异的dy/dx。这假定x值是连续的且间隔均匀

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

找到最大dy/dx的索引，并使用它们来获得产生它的值

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

---

---

中间数组-值在对角线上反映

>>> 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. ]]

---

我不知道如何更好地解决这个问题，但我认为您需要动态规划。我不太清楚为什么您的预期结果是

82/52

。您提到您正在寻找

dy/dx

，这意味着它应该

（82-52）/（6-3）=10

。然而，还有另一个答案是

（71-52）/（4-3）=19

，它是>10。似乎你必须检查每一种可能性-每一点与所有其他点相比。听起来像是嵌套循环；您可能可以在内部循环上做手脚，然后从外部循环的当前索引开始。或者，您可以使用外部库强制执行，但可以将嵌套循环推送到C。在许多情况下，可以通过y-coord将点放入max堆来改进强制执行方法。然后，在从左到右处理每个点时，从最大堆中删除大于当前点的所有点，将其余点与之比较，然后将当前点添加到堆中。

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

>>> 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. ]]