的Python RuntimeWarning溢出double_scalars

Question

我試圖端口一個「C」代碼到Python遇到的，這就是我的編碼：

scale = 1.0/(rows * cols) 
RemoveConstantBiasFrom(rarray, scale) 
zarray = rarray[:] 
zarray = DCT(zarray, rows, cols) 

zarray = zarray.flatten() 

beta = np.dot(rarray, zarray) 

if iloop == 0: 
    parray = zarray[:] 
else: 
    btemp = beta/beta_prev 
    parray = zarray + btemp * parray 
RemoveConstantBiasFrom(parray, scale) 
beta_prev = beta 
for j in range(rows): 
     for i in range(cols): 
      k = j * rows + i 

      k1 = k + 1 if i < cols - 1 else k - 1 
      k2 = k - 1 if i > 0 else k + 1 
      k3 = k + cols if j < rows - 1 else k - cols 
      k4 = k - cols if j > 0 else k + cols 


      w1 = SIMIN(wts[k], wts[k1]) 
      w2 = SIMIN(wts[k], wts[k2]) 
      w3 = SIMIN(wts[k], wts[k3]) 
      w4 = SIMIN(wts[k], wts[k4]) 

      A = (w1 + w2 + w3 + w4) * parray[k] 
      B = (w1 * parray[k1] + w2 * parray[k2]) 
      C = (w3 * parray[k3] + w4 * parray[k4]) 

      zarray[k] = A - (B + C) 

wts和parray兩個扁平的陣列，262144個值（512×512矩陣）。當我正在執行此操作時，我得到：

test.py:152: RuntimeWarning: overflow encountered in double_scalars 
    B = (w1 * parray[k1] + w2 * parray[k2]) 
test.py:154: RuntimeWarning: overflow encountered in double_scalars 
    C = (w3 * parray[k3] + w4 * parray[k4]) 
test.py:155: RuntimeWarning: overflow encountered in double_scalars 
    zarray[k] = A - B + C 

因此，我開始「調試」代碼。

1）我把print到max(parray)環之前，我得到：

Maximum value for parray 15.2665322926 

2）我添加了一個if語句在循環內觀看parray[k1]行爲if parray[k1] > maxparray: print k1，我得到了很多的「K1的」 ：

... 
251902 
252414 
252926 
253438 
253950 
254462 
254974 
255486 
255998 
256510 
257022 
257534 
258046 
258558 
259070 
259582 
260094 
260606 
261118 
261630 
262142 

所以，問題：如果我從來沒有爲什麼我收到超過max(parray)不同的值改爲「粒子陣列」？

這是C代碼：

int  i, j, k; 
    int  k1, k2, k3, k4; 
    double sum, w1, w2, w3, w4, btemp, delta, avg, scale; 
    float *wts; 

    scale = 1.0/(xsize*ysize); 
    /* remove constant bias from rarray */ 
    for (k=0, avg=0.0; k<xsize*ysize; k++) avg += rarray[k]; 
    avg *= scale; 
    for (k=0; k<xsize*ysize; k++) rarray[k] -= avg; 
    /* compute cosine transform solution of Laplacian in rarray */ 
    for (k=0; k<xsize*ysize; k++) { 
    zarray[k] = rarray[k]; 
    } 
    DCT(zarray, xsize, ysize, xcos, ycos); 
    /* calculate beta and parray */ 
    for (k=0, *beta=0.0; k<xsize*ysize; k++) { 
    *beta += rarray[k]*zarray[k]; 
    } 
    printf("beta = %lf\n", *beta); 
    if (iloop == 0) { 
    for (k=0; k<xsize*ysize; k++) { 
     parray[k] = zarray[k]; 
    } 
    } 
    else { 
    btemp = (*beta)/(*beta_prev); 
    for (k=0; k<xsize*ysize; k++) { 
     parray[k] = zarray[k] + btemp*parray[k]; 
    } 
    } 
    /* remove constant bias from parray */ 
    for (k=0, avg=0.0; k<xsize*ysize; k++) avg += parray[k]; 
    avg *= scale; 
    for (k=0; k<xsize*ysize; k++) parray[k] -= avg; 
    *beta_prev = *beta; 
    /* calculate Qp */ 
    for (j=0; j<ysize; j++) { 
    for (i=0; i<xsize; i++) { 
     k = j*xsize + i; 
     k1 = (i<xsize-1) ? k + 1 : k - 1; 
     k2 = (i>0) ? k - 1 : k + 1; 
     k3 = (j<ysize-1) ? k + xsize : k - xsize; 
     k4 = (j>0) ? k - xsize : k + xsize; 
     if (dxwts==NULL && dywts==NULL) { /* unweighted */ 
     w1 = w2 = w3 = w4 = 1.0; 
     } 
     else if (dxwts==NULL || dywts==NULL) { /* one set of wts */ 
     wts = (dxwts) ? dxwts : dywts; 
     w1 = SIMIN(wts[k], wts[k1]); 
     w2 = SIMIN(wts[k], wts[k2]); 
     w3 = SIMIN(wts[k], wts[k3]); 
     w4 = SIMIN(wts[k], wts[k4]); 
     } 
     else { /* dxwts and dywts are both supplied */ 
     w1 = dxwts[k]; 
     w2 = (i>0) ? dxwts[k-1] : dxwts[k]; 
     w3 = dywts[k]; 
     w4 = (j>0) ? dywts[k-xsize] : dywts[k]; 
     } 

     zarray[k] = (w1 + w2 + w3 + w4)*parray[k] 
         - (w1*parray[k1] + w2*parray[k2] 
           + w3*parray[k3] + w4*parray[k4]); 
    } 
    } 

我只是路過dxwts（一組權重），所以其他人都沒有必要，這就是爲什麼我使用一個if語句我，這裏是四民：

#define SIMIN(x,y) (((x)*(x) < (y)*(y)) ? (x)*(x) : (y)*(y)) 

Answer 1

問題是，我複製陣列的方式，正確的做法是：

zarray[:] = rarray 

Answer 2

最有可能的是，parray和zarray是相同的陣列。

如果你這樣做：

zarray = DCTF() 
parray = zarray 

然後zarray和parray是同一陣列和zarray改變一個元素將在parray用途是可見的。 （這不是從C顯著不同）

如果你想要一個副本，你可以這樣做：

zarray = DCTF() 
parray = zarray[:]