Simplify mathematical expressions and remove unused variables

astrofrog · astrofrog · commit ce4854581456 · 2018-10-31T23:55:18.000Z
diff --git a/astropy/convolution/src/convolve.c b/astropy/convolution/src/convolve.c
@@ -199,20 +199,16 @@ FORCE_INLINE void convolve1d(DTYPE * const result,
     // when threaded. Without these, compile time constant conditionals may
     // not be optimized away.
     const size_t nx = _nx;
-    const size_t nkx = _nkx;
     const bool nan_interpolate = _nan_interpolate;
     const bool padded = _padded;
 
     // Thread locals
     const size_t wkx = _wkx;
-    const size_t nkx_minus_1 = nkx-1;
-    size_t wkx_minus_i;
+    size_t wkx_plus_i;
     size_t ker_i;
     const omp_iter_var nx_minus_wkx = nx - wkx;
     size_t i_minus_wkx;
-    const size_t wkx_plus_1 = wkx + 1;
     omp_iter_var i_plus_wkx_plus_1;
-    size_t nkx_minus_1_minus_wkx_plus_i;
     size_t result_index;
 
     DTYPE top, bot=0., ker, val;
@@ -223,18 +219,17 @@ FORCE_INLINE void convolve1d(DTYPE * const result,
 #endif
     for (i = wkx; i < nx_minus_wkx; ++i)
     {
-        wkx_minus_i = wkx - i; // wkx - 1
+        wkx_plus_i = wkx + i; // wkx + i
         i_minus_wkx = i - wkx; //i - wkx
-        i_plus_wkx_plus_1 = i + wkx_plus_1; // i + wkx + 1
-        nkx_minus_1_minus_wkx_plus_i = nkx_minus_1 - wkx_minus_i; // nkx - 1 - (wkx - i)
+        i_plus_wkx_plus_1 = wkx_plus_i + 1; // i + wkx + 1
 
         top = 0.;
         if (nan_interpolate) // compile time constant
             bot = 0.;
         {omp_iter_var ii;
         for (ii = i_minus_wkx; ii < i_plus_wkx_plus_1; ++ii)
         {
-            ker_i = nkx_minus_1_minus_wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
+            ker_i = wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
             val = f[ii];
             ker = g[ker_i];
             if (nan_interpolate) // compile time constant
@@ -306,24 +301,20 @@ FORCE_INLINE void convolve2d(DTYPE * const result,
     // when threaded. Without these, compile time constant conditionals may
     // not be optimized away.
     const size_t nx = _nx, ny = _ny;
-    const size_t nkx = _nkx, nky = _nky;
+    const size_t nky = _nky;
     const bool nan_interpolate = _nan_interpolate;
     const bool padded = _padded;
 
     // Thread locals
     const size_t wkx = _wkx;
     const size_t wky = _wky;
-    const size_t nkx_minus_1 = nkx-1, nky_minus_1 = nky-1;
-    size_t wkx_minus_i, wky_minus_j;
+    size_t wkx_plus_i, wky_plus_j;
     size_t ker_i, ker_j;
     const omp_iter_var nx_minus_wkx = nx - wkx;
     const omp_iter_var ny_minus_wky = ny - wky;
     const size_t ny_minus_2wky = ny - 2 * wky;
     size_t i_minus_wkx, j_minus_wky;
-    const size_t wkx_plus_1 = wkx + 1;
-    const size_t wky_plus_1 = wky + 1;
     omp_iter_var i_plus_wkx_plus_1, j_plus_wky_plus_1;
-    size_t nkx_minus_1_minus_wkx_plus_i, nky_minus_1_minus_wky_plus_j;
     size_t result_index;
 
     DTYPE top, bot=0., ker, val;
@@ -334,30 +325,28 @@ FORCE_INLINE void convolve2d(DTYPE * const result,
 #endif
     for (i = wkx; i < nx_minus_wkx; ++i)
     {
-        wkx_minus_i = wkx - i; // wkx - 1
+        wkx_plus_i = wkx + i; // wkx + 1
         i_minus_wkx = i - wkx; //i - wkx
-        i_plus_wkx_plus_1 = i + wkx_plus_1; // i + wkx + 1
-        nkx_minus_1_minus_wkx_plus_i = nkx_minus_1 - wkx_minus_i; // nkx - 1 - (wkx - i)
+        i_plus_wkx_plus_1 = wkx_plus_i + 1; // i + wkx + 1
 
         {omp_iter_var j;
         for (j = wky; j < ny_minus_wky; ++j)
         {
-            wky_minus_j = wky - j; // wky - j
+            wky_plus_j = wky + j; // wky + j
             j_minus_wky = j - wky; // j - wky
-            j_plus_wky_plus_1 = j + wky_plus_1; // j + wky + 1
-            nky_minus_1_minus_wky_plus_j = nky_minus_1 - wky_minus_j; // nky - 1 - (wky - i)
+            j_plus_wky_plus_1 = wky_plus_j + 1; // j + wky + 1
 
             top = 0.;
             if (nan_interpolate) // compile time constant
                 bot = 0.;
             {omp_iter_var ii;
             for (ii = i_minus_wkx; ii < i_plus_wkx_plus_1; ++ii)
             {
-                ker_i = nkx_minus_1_minus_wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
+                ker_i = wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
                 {omp_iter_var jj;
                 for (jj = j_minus_wky; jj < j_plus_wky_plus_1; ++jj)
                 {
-                    ker_j = nky_minus_1_minus_wky_plus_j - jj; // nky - 1 - (wky + jj - j)
+                    ker_j = wky_plus_j - jj; // nky - 1 - (wky + jj - j)
                     val = f[ii*ny + jj]; //[ii, jj];
                     ker = g[ker_i*nky + ker_j]; // [ker_i, ker_j];
                     if (nan_interpolate) // compile time constant
@@ -433,16 +422,15 @@ FORCE_INLINE void convolve3d(DTYPE * const result,
     // when threaded. Without these, compile time constant conditionals may
     // not be optimized away.
     const size_t nx = _nx, ny = _ny, nz = _nz;
-    const size_t nkx = _nkx, nky = _nky, nkz = _nkz;
+    const size_t nky = _nky, nkz = _nkz;
     const bool nan_interpolate = _nan_interpolate;
     const bool padded = _padded;
 
     // Thread locals
     const size_t wkx = _wkx;
     const size_t wky = _wky;
     const size_t wkz = _wkz;
-    const size_t nkx_minus_1 = nkx-1, nky_minus_1 = nky-1, nkz_minus_1 = nkz-1;
-    size_t wkx_minus_i, wky_minus_j, wkz_minus_k;
+    size_t wkx_plus_i, wky_plus_j, wkz_plus_k;
     size_t ker_i, ker_j, ker_k;
     const size_t nx_minus_wkx = nx - wkx;
     const omp_iter_var ny_minus_wky = ny - wky;
@@ -451,11 +439,7 @@ FORCE_INLINE void convolve3d(DTYPE * const result,
     const size_t nz_minus_2wkz = nz - 2 * wkz;
 
     size_t i_minus_wkx, j_minus_wky, k_minus_wkz;
-    const size_t wkx_plus_1 = wkx + 1;
-    const size_t wky_plus_1 = wky + 1;
-    const size_t wkz_plus_1 = wkz + 1;
     omp_iter_var i_plus_wkx_plus_1, j_plus_wky_plus_1, k_plus_wkz_plus_1;
-    size_t nkx_minus_1_minus_wkx_plus_i, nky_minus_1_minus_wky_plus_j, nkz_minus_1_minus_wkz_plus_k;
     size_t result_index;
 
     DTYPE top, bot=0., ker, val;
@@ -466,42 +450,39 @@ FORCE_INLINE void convolve3d(DTYPE * const result,
 #endif
     for (i = wkx; i < nx_minus_wkx; ++i)
     {
-        wkx_minus_i = wkx - i; // wkx - 1
+        wkx_plus_i = wkx + i; // wkx + i
         i_minus_wkx = i - wkx; //i - wkx
-        i_plus_wkx_plus_1 = i + wkx_plus_1; // i + wkx + 1
-        nkx_minus_1_minus_wkx_plus_i = nkx_minus_1 - wkx_minus_i; // nkx - 1 - (wkx - i)
+        i_plus_wkx_plus_1 = wkx_plus_i + 1; // i + wkx + 1
 
         {omp_iter_var j;
         for (j = wky; j < ny_minus_wky; ++j)
         {
-            wky_minus_j = wky - j; // wky - j
+            wky_plus_j = wky + j; // wky + j
             j_minus_wky = j - wky; // j - wky
-            j_plus_wky_plus_1 = j + wky_plus_1; // j + wky + 1
-            nky_minus_1_minus_wky_plus_j = nky_minus_1 - wky_minus_j; // nky - 1 - (wky - i)
+            j_plus_wky_plus_1 = wky_plus_j + 1; // j + wky + 1
 
             {omp_iter_var k;
             for (k = wkz; k < nz_minus_wkz; ++k)
             {
-                wkz_minus_k = wkz - k; // wkz - k
+                wkz_plus_k = wkz + k; // wkz + k
                 k_minus_wkz = k - wkz; // k - wkz
-                k_plus_wkz_plus_1 = k + wkz_plus_1; // k + wkz + 1
-                nkz_minus_1_minus_wkz_plus_k = nkz_minus_1 - wkz_minus_k; // nkz - 1 - (wkz - i)
+                k_plus_wkz_plus_1 = wkz_plus_k + 1; // k + wkz + 1
 
                 top = 0.;
                 if (nan_interpolate) // compile time constant
                     bot = 0.;
                 {omp_iter_var ii;
                 for (ii = i_minus_wkx; ii < i_plus_wkx_plus_1; ++ii)
                 {
-                    ker_i = nkx_minus_1_minus_wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
+                    ker_i = wkx_plus_i - ii; // nkx - 1 - (wkx + ii - i)
                     {omp_iter_var jj;
                     for (jj = j_minus_wky; jj < j_plus_wky_plus_1; ++jj)
                     {
-                        ker_j = nky_minus_1_minus_wky_plus_j - jj; // nky - 1 - (wky + jj - j)
+                        ker_j = wky_plus_j - jj; // nky - 1 - (wky + jj - j)
                         {omp_iter_var kk;
                         for (kk = k_minus_wkz; kk < k_plus_wkz_plus_1; ++kk)
                         {
-                            ker_k = nkz_minus_1_minus_wkz_plus_k - kk; // nkz - 1 - (wkz + kk - k)
+                            ker_k = wkz_plus_k - kk; // nkz - 1 - (wkz + kk - k)
 
                             val = f[(ii*ny + jj)*nz + kk]; //[ii, jj, kk];
                             ker = g[(ker_i*nky + ker_j)*nkz + ker_k]; // [ker_i, ker_j, ker_k];
