fixed compiler warnings

Author: DiamonDinoia

include/finufft/spreadinterp.h

@@ -35,9 +35,8 @@ template<typename T>
 FINUFFT_EXPORT int FINUFFT_CDECL spreadinterp(
     UBIGINT N1, UBIGINT N2, UBIGINT N3, T *data_uniform, UBIGINT M, T *kx, T *ky, T *kz,
     T *data_nonuniform, const finufft_spread_opts &opts);
-template<typename T>
+
 FINUFFT_EXPORT int FINUFFT_CDECL spreadcheck(UBIGINT N1, UBIGINT N2, UBIGINT N3,
-                                             UBIGINT N, T *kx, T *ky, T *kz,
                                              const finufft_spread_opts &opts);
 template<typename T>
 FINUFFT_EXPORT int FINUFFT_CDECL indexSort(std::vector<BIGINT> &sort_indices, UBIGINT N1,

src/fft.cpp

@@ -19,8 +19,8 @@ template std::vector<int> gridsize_for_fft<float>(const FINUFFT_PLAN_T<float> &p
 template std::vector<int> gridsize_for_fft<double>(const FINUFFT_PLAN_T<double> &p);
 
 template<typename TF>
-void do_fft(const FINUFFT_PLAN_T<TF> &p, std::complex<TF> *fwBatch, int ntrans_actual,
-            bool adjoint) {
+void do_fft(const FINUFFT_PLAN_T<TF> &p, std::complex<TF> *fwBatch,
+            int ntrans_actual [[maybe_unused]], bool adjoint) {
 #ifdef FINUFFT_USE_DUCC0
   size_t nthreads = min<size_t>(MY_OMP_GET_MAX_THREADS(), p.opts.nthreads);
   const auto ns   = gridsize_for_fft(p);

src/finufft_core.cpp

@@ -815,7 +815,7 @@ int FINUFFT_PLAN_T<TF>::setpts(BIGINT nj, TF *xj, TF *yj, TF *zj, BIGINT nk, TF
   if (type != 3) {          // ------------------ TYPE 1,2 SETPTS -------------------
                             // (all we can do is check and maybe bin-sort the NU pts)
     XYZ     = {xj, yj, zj}; // plan must keep pointers to user's fixed NU pts
-    int ier = spreadcheck(nfdim[0], nfdim[1], nfdim[2], nj, xj, yj, zj, spopts);
+    int ier = spreadcheck(nfdim[0], nfdim[1], nfdim[2], spopts);
     if (ier)                // no warnings allowed here
       return ier;
     timer.restart();

src/spreadinterp.cpp

@@ -34,7 +34,7 @@ struct zip_hi {
   }
 };
 template<unsigned cap> struct reverse_index {
-  static constexpr unsigned get(unsigned index, const unsigned size) {
+  static constexpr unsigned get(unsigned index, const unsigned /*size*/) {
     return index < cap ? (cap - 1 - index) : index;
   }
 };
@@ -280,7 +280,8 @@ template<typename T, uint8_t w, uint8_t upsampfact,
          class simd_type =
              xsimd::make_sized_batch_t<T, find_optimal_simd_width<T, w>()>> // aka ns
 static FINUFFT_ALWAYS_INLINE void eval_kernel_vec_Horner(
-    T *FINUFFT_RESTRICT ker, T x, const finufft_spread_opts &opts) noexcept
+    T *FINUFFT_RESTRICT ker, T x,
+    const finufft_spread_opts &opts [[maybe_unused]]) noexcept
 /* Fill ker[] with Horner piecewise poly approx to [-w/2,w/2] ES kernel eval at
 x_j = x + j,  for j=0,..,w-1.  Thus x in [-w/2,-w/2+1].   w is aka ns.
 This is the current evaluation method, since it's faster (except i7 w=16).
@@ -1394,7 +1395,7 @@ template<typename T>
 static void bin_sort_singlethread(std::vector<BIGINT> &ret, UBIGINT M, const T *kx,
                                   const T *ky, const T *kz, UBIGINT N1, UBIGINT N2,
                                   UBIGINT N3, double bin_size_x, double bin_size_y,
-                                  double bin_size_z, int debug)
+                                  double bin_size_z, int debug [[maybe_unused]])
 /* Returns permutation of all nonuniform points with good RAM access,
  * ie less cache misses for spreading, in 1D, 2D, or 3D. Single-threaded version
  *
@@ -1466,9 +1467,10 @@ static void bin_sort_singlethread(std::vector<BIGINT> &ret, UBIGINT M, const T *
 }
 
 template<typename T>
-static void bin_sort_multithread(std::vector<BIGINT> &ret, UBIGINT M, T *kx, T *ky, T *kz,
-                                 UBIGINT N1, UBIGINT N2, UBIGINT N3, double bin_size_x,
-                                 double bin_size_y, double bin_size_z, int debug,
+static void bin_sort_multithread(std::vector<BIGINT> &ret, UBIGINT M, T *kx, T *ky,
+                                 T *kz, UBIGINT N1, UBIGINT N2, UBIGINT N3,
+                                 double bin_size_x, double bin_size_y,
+                                 double bin_size_z, int debug [[maybe_unused]],
                                  int nthr)
 /* Mostly-OpenMP'ed version of bin_sort.
    For documentation see: bin_sort_singlethread.
@@ -1680,7 +1682,7 @@ FINUFFT_EXPORT int FINUFFT_CDECL spreadinterp(
    Tidy, Barnett 5/20/20. Tidy doc, Barnett 10/22/20.
 */
 {
-  int ier = spreadcheck(N1, N2, N3, M, kx, ky, kz, opts);
+  int ier = spreadcheck(N1, N2, N3, opts);
   if (ier) return ier;
   std::vector<BIGINT> sort_indices(M);
   int did_sort = indexSort(sort_indices, N1, N2, N3, M, kx, ky, kz, opts);
@@ -1696,7 +1698,7 @@ template FINUFFT_EXPORT int FINUFFT_CDECL spreadinterp<double>(
     UBIGINT N1, UBIGINT N2, UBIGINT N3, double *data_uniform, UBIGINT M, double *kx,
     double *ky, double *kz, double *data_nonuniform, const finufft_spread_opts &opts);
 
-static constexpr uint8_t ndims_from_Ns(const UBIGINT N1, const UBIGINT N2,
+static constexpr uint8_t ndims_from_Ns(const UBIGINT /*N1*/, const UBIGINT N2,
                                        const UBIGINT N3)
 /* rule for getting number of spreading dimensions from the list of Ns per dim.
    Split out, Barnett 7/26/18
@@ -1705,9 +1707,7 @@ static constexpr uint8_t ndims_from_Ns(const UBIGINT N1, const UBIGINT N2,
   return 1 + (N2 > 1) + (N3 > 1);
 }
 
-template<typename T>
-int spreadcheck(UBIGINT N1, UBIGINT N2, UBIGINT N3, UBIGINT M, T *kx, T *ky, T *kz,
-                const finufft_spread_opts &opts)
+int spreadcheck(UBIGINT N1, UBIGINT N2, UBIGINT N3, const finufft_spread_opts &opts)
 /* This does just the input checking and reporting for the spreader.
    See spreadinterp() for input arguments and meaning of returned value.
    Split out by Melody Shih, Jun 2018. Finiteness chk Barnett 7/30/18.
@@ -1729,11 +1729,6 @@ int spreadcheck(UBIGINT N1, UBIGINT N2, UBIGINT N3, UBIGINT M, T *kx, T *ky, T *
   }
   return 0;
 }
-template int spreadcheck<float>(UBIGINT N1, UBIGINT N2, UBIGINT N3, UBIGINT M, float *kx,
-                                float *ky, float *kz, const finufft_spread_opts &opts);
-template int spreadcheck<double>(UBIGINT N1, UBIGINT N2, UBIGINT N3, UBIGINT M,
-                                 double *kx, double *ky, double *kz,
-                                 const finufft_spread_opts &opts);
 
 template<typename T>
 int indexSort(std::vector<BIGINT> &sort_indices, UBIGINT N1, UBIGINT N2, UBIGINT N3,