0

我有一个巨大的嵌套 for 循环......总共 10 个，但为了说明，我包括 6 个。我正在做一个求和（在多个索引上；incides 不是独立的！）。任何内部 for 循环中的索引取决于外部循环的索引（一个实例除外）。最里面的循环包含一个操作，在该操作中，我根据 8 个不同的条件对数组（名为“w”）进行切片，所有条件都使用“&”和“|”组合。还有一个“HB”函数将这个切片数组（名为“wrange”）作为参数，对其执行一些操作并返回一个相同大小的数组。

此切片和执行“HB”函数的时间刻度分别为 300-400 微秒和 100 微秒。我需要彻底降低它。到纳秒。！！

尝试使用字典而不是数组（我正在切片）。它要慢得多。尝试存储所有可能值的切片数组。这本身就是一个非常庞大的计算，因为有许多可能的条件组合（这些条件间接取决于 for 循环的索引）

s 从 1 到 49

t 从 -s 到 s

l,n 有 641 种组合

在这里，我发布了一个 s,t 和一个 l,n 组合的值以进行说明。

s = 7
t = -7 
l = 72
n = 12
Nl = Dictnorm[n,l]
Gamma_l = Dictfwhm[n,l]
Dictc1 = {}
Dictc2 = {}
Dictwrange = {}
DictH = {}
DictG = {}
product = []
startm = max(-l-t,-l)
endm = min(l-t,l)+1
sum5 = 0
for sp in range(s-2,s+3): #s'
    sum4 = 0
    for tp in range(-sp,-sp+1): #t'
        #print(tp)
        sum3 = 0
        integral = 1
        for lp in range(l-2,l+3): #l'
            sum2 = 0
            if (n,lp) in Dictknl2.keys():
                N1 = Dictnorm[n,lp]
                Gamma_1 = Dictfwhm[n,lp]
                for lpp in range(l-2,l+3): #l"
                    sum1 = 0
                    if ((sp+lpp-lp)%2 == 1 and sp>=abs(lpp-lp) and 
                        lp>=abs(sp-lpp) and lpp>=abs(sp-lp) and 
                        (n,lpp) in Dictknl2.keys()):
                        F = f(lpp,lp,sp)
                        N2 = Dictnorm[n,lpp]
                        Gamma_2 = Dictfwhm[n,lpp]
                        for m in range(startm, endm): #m
                            sum0 = 0
                            L1 = LKD(n,l,m,l,m)
                            L2 = LKD(n,l,m+t,l,m+t)
                            for mp in range(max(m+t-tp-5,m-5), 
                                            min(m+5,m+t-tp+5)+1): #m'
                                if (abs(mp)<=lp and abs(mp)<=lpp and 
                                    abs(mp+tp)<=lp and abs(mp+tp)<=lpp 
                                    and LKD(n,l,m,lp,mp)!=0 
                                    and LKD(n,l,m+t,lpp,mp+tp)!=0):
                                    c3 = Dictomega[n,lp,mp+tp]
                                    c4 = Dictomega[n,lpp,mp]
                                    wrange = np.unique(np.concatenate
                                             ((Dictwrange[m],                                  
                                             w[((w>=(c3-Gamma_1))&
                                             ((c3+Gamma_1)>=w))|
                                             ((w>=(c4-Gamma_2))& 
                                             ((c4+Gamma_2)>=w))])))
                                    factor = (sum(
                                             HB(Dictc1[n,l,m+t],
                                                Dictc2[n,l,m],Nl,
                                                Nl,Gamma_l,
                                                Gamma_l,wrange,
                                                Sigma).conjugate()
                                             *HB(c3,c4,N1,N2,Gamma_1, 
                                              Gamma_2,wrange,0)*L1*L2)
                                             *LKD(n,l,m,lp,mp)
                                             *LKD(n,l,m+t,lpp,mp+tp)                    *DictG[m]
                                             *gamma(lpp,sp,lp,tp,mp)
                                             *F)
                                    sum0 = sum0 + factor #sum over m'
                            sum1 = sum1 + sum0 #sum over m
                    sum2 = sum2 + sum1 #sum over l"
                sum3 = sum3 + sum2 #sum over l'
        sum4 = sum4 + sum3*integral #sum over t' 
    sum5 = sum5 + sum4 #sum over s'
z = (1/(sum(product)))*sum5
print(z.real,z.imag,l,n)

TL;博士

def HB(a,...f,array1): #########timesucker
    perform_some_operations_on_array1_using_a_b_c_d
    return operated_on_array1


for i in ():
    for j in ():
       ...
         ...
          for o in ():
              array1 = w[w>some_function1(i,j,..k) & 
                         w<some_function2(i,j,..k) |.....] #########timesucker
              factor = HB(a,....f,array1) * HB(g,...k,array1) * 
                       alpha*beta*gamma....

运行整个部分大约需要 30 秒。我需要把它降到尽可能低。1秒是最小目标

4

0 回答 0