some cleanup & removed linux headers on windows

.gitignore

@@ -26,7 +26,7 @@ fortran/examples/nufft2dmany_demof
 fortran/examples/nufft3d_demof
 test/dumbinputs
 test/finufft1d_basicpassfail
-test/testutils
+test/testlib
 __pycache__*
 
 docs/_build

CMakeLists.txt

@@ -248,27 +248,19 @@ function(set_finufft_options target)
 endfunction()
 
 if(FINUFFT_USE_CPU)
-  # Main finufft libraries
-  if(NOT FINUFFT_STATIC_LINKING)
-    add_library(
-      finufft SHARED
+  set(FINUFFT_SOURCES
       src/spreadinterp.cpp
-      src/utils.cpp
       contrib/legendre_rule_fast.cpp
       src/fft.cpp
       src/finufft_core.cpp
       src/c_interface.cpp
+      src/finufft_utils.cpp
       fortran/finufftfort.cpp)
+  # Main finufft libraries
+  if(NOT FINUFFT_STATIC_LINKING)
+    add_library(finufft SHARED ${FINUFFT_SOURCES})
   else()
-    add_library(
-      finufft STATIC
-      src/spreadinterp.cpp
-      src/utils.cpp
-      contrib/legendre_rule_fast.cpp
-      src/fft.cpp
-      src/finufft_core.cpp
-      src/c_interface.cpp
-      fortran/finufftfort.cpp)
+    add_library(finufft STATIC ${FINUFFT_SOURCES})
   endif()
   set_finufft_options(finufft)
 

devel/foldrescale.cpp

@@ -1,7 +1,6 @@
-#include "finufft/defs.h"
+#include "finufft/test_defs.h"
 #include <benchmark/benchmark.h>
 #include <cmath>
-#include <immintrin.h>
 #include <iostream>
 #include <random>
 // no vectorize
@@ -17,22 +16,22 @@
    This should be done in C++ not as a macro, someday.
 */
 #define FOLDRESCALE(x, N, p)                                                \
-  (p ? (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)M_1_2PI * N) \
+  (p ? (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)INV_2PI * N) \
      : (x >= 0.0 ? (x < (FLT)N ? x : x - (FLT)N) : x + (FLT)N))
 
 #define FOLDRESCALE04(x, N, p)                                                       \
-  (p ? ((x * FLT(M_1_2PI) + FLT(0.5)) - floor(x * FLT(M_1_2PI) + FLT(0.5))) * FLT(N) \
+  (p ? ((x * FLT(INV_2PI) + FLT(0.5)) - floor(x * FLT(INV_2PI) + FLT(0.5))) * FLT(N) \
      : ((x / FLT(N)) - floor(x / FLT(N))) * FLT(N))
 
 #define FOLDRESCALE05(x, N, p)                                                       \
-  FLT(N) * (p ? ((x * FLT(M_1_2PI) + FLT(0.5)) - floor(x * FLT(M_1_2PI) + FLT(0.5))) \
+  FLT(N) * (p ? ((x * FLT(INV_2PI) + FLT(0.5)) - floor(x * FLT(INV_2PI) + FLT(0.5))) \
               : ((x / FLT(N)) - floor(x / FLT(N))))
 
 inline __attribute__((always_inline)) FLT foldRescale00(FLT x, BIGINT N, bool p) {
   FLT result;
   FLT fN = FLT(N);
   if (p) {
-    static constexpr FLT x2pi = FLT(M_1_2PI);
+    static constexpr FLT x2pi = FLT(INV_2PI);
     result                    = x * x2pi + FLT(0.5);
     result -= floor(result);
   } else {
@@ -44,14 +43,14 @@ inline __attribute__((always_inline)) FLT foldRescale00(FLT x, BIGINT N, bool p)
 }
 
 inline __attribute__((always_inline)) FLT foldRescale01(FLT x, BIGINT N, bool p) {
-  return p ? (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)M_1_2PI * N)
+  return p ? (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)INV_2PI * N)
            : (x >= 0.0 ? (x < (FLT)N ? x : x - (FLT)N) : x + (FLT)N);
 }
 
 template<bool p>
 inline __attribute__((always_inline)) FLT foldRescale02(FLT x, BIGINT N) {
   if constexpr (p) {
-    return (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)M_1_2PI * N);
+    return (x + (x >= -PI ? (x < PI ? PI : -PI) : 3 * PI)) * ((FLT)INV_2PI * N);
   } else {
     return (x >= 0.0 ? (x < (FLT)N ? x : x - (FLT)N) : x + (FLT)N);
   }
@@ -62,7 +61,7 @@ inline __attribute__((always_inline)) FLT foldRescale03(FLT x, BIGINT N) {
   FLT result;
   FLT fN = FLT(N);
   if constexpr (p) {
-    static constexpr FLT x2pi = FLT(M_1_2PI);
+    static constexpr FLT x2pi = FLT(INV_2PI);
     result                    = std::fma(x, x2pi, FLT(0.5));
     result -= floor(result);
   } else {
@@ -73,7 +72,6 @@ inline __attribute__((always_inline)) FLT foldRescale03(FLT x, BIGINT N) {
   return result * fN;
 }
 
-
 static std::mt19937_64 gen;
 static std::uniform_real_distribution<> dis(-10, 10);
 static const auto N = std::uniform_int_distribution<>{0, 1000}(gen);
@@ -185,7 +183,6 @@ static void BM_FoldRescale05N(benchmark::State &state) {
   }
 }
 
-
 BENCHMARK(BM_BASELINE)->Iterations(10000000);
 BENCHMARK(BM_FoldRescaleMacro)->Iterations(1000000);
 BENCHMARK(BM_FoldRescale00)->Iterations(1000000);

include/cufinufft/utils.h

@@ -22,8 +22,10 @@
 
 #include <thrust/extrema.h>
 
+#ifndef _USE_MATH_DEFINES
 #define _USE_MATH_DEFINES
-#include <math.h>
+#endif
+#include <cmath>
 
 #if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 600 || defined(__clang__)
 #else
@@ -96,21 +98,6 @@ class WithCudaDevice {
   }
 };
 
-// jfm timer class
-class CNTime {
-public:
-  void start();
-  double restart();
-  double elapsedsec();
-
-private:
-#ifdef _WIN32
-  LARGE_INTEGER initial, frequency;
-#else
-  struct timeval initial;
-#endif
-};
-
 // ahb math helpers
 CUFINUFFT_BIGINT next235beven(CUFINUFFT_BIGINT n, CUFINUFFT_BIGINT b);
 

include/finufft/finufft_utils.hpp

@@ -0,0 +1,73 @@
+// Header for utils.cpp, a little library of low-level array stuff.
+// These are just the functions which depend on single/double precision (FLT)
+
+#pragma once
+
+#include <chrono>
+#include <cmath>
+
+#include "finufft_core.h"
+
+//  for CNTime...
+//  using chrono since the interface is portable between linux and windows
+
+namespace finufft::utils {
+
+template<typename T>
+FINUFFT_ALWAYS_INLINE void arrayrange(BIGINT n, const T *a, T *lo, T *hi)
+// With a a length-n array, writes out min(a) to lo and max(a) to hi,
+// so that all a values lie in [lo,hi].
+// If n==0, lo and hi are not finite.
+{
+  *lo = INFINITY;
+  *hi = -INFINITY;
+  for (BIGINT m = 0; m < n; ++m) {
+    if (a[m] < *lo) *lo = a[m];
+    if (a[m] > *hi) *hi = a[m];
+  }
+}
+template<typename T>
+FINUFFT_ALWAYS_INLINE void arraywidcen(BIGINT n, const T *a, T *w, T *c)
+// Writes out w = half-width and c = center of an interval enclosing all a[n]'s
+// Only chooses a nonzero center if this increases w by less than fraction
+// ARRAYWIDCEN_GROWFRAC defined in finufft_core.h.
+// This prevents rephasings which don't grow nf by much. 6/8/17
+// If n==0, w and c are not finite.
+{
+  T lo, hi;
+  arrayrange(n, a, &lo, &hi);
+  *w = (hi - lo) / 2;
+  *c = (hi + lo) / 2;
+  if (std::abs(*c) < ARRAYWIDCEN_GROWFRAC * (*w)) {
+    *w += std::abs(*c);
+    *c = 0.0;
+  }
+}
+
+BIGINT next235even(BIGINT n);
+
+// jfm's timer class
+class FINUFFT_EXPORT CNTime {
+public:
+  FINUFFT_NEVER_INLINE void start();
+  FINUFFT_NEVER_INLINE double restart();
+  FINUFFT_NEVER_INLINE double elapsedsec() const;
+
+private:
+  double initial;
+};
+
+// openmp helpers
+int get_num_threads_parallel_block();
+
+} // namespace finufft::utils
+
+// thread-safe rand number generator for Windows platform
+#ifdef _WIN32
+#include <random>
+namespace finufft {
+namespace common {
+int rand_r(unsigned int *seedp);
+} // namespace common
+} // namespace finufft
+#endif

include/finufft/test_defs.h

@@ -16,7 +16,6 @@
 
 // convenient private finufft internals
 #include <finufft/finufft_core.h>
-#include <finufft/utils.h>
 #include <memory>
 
 // --------------- Private data types for compilation in either prec ---------