fixed cuda reformatting, updated hooks

DiamonDinoia · DiamonDinoia · commit 463fb384f944 · 2025-08-04T06:11:34.000-04:00
diff --git a/.clang-format b/.clang-format
@@ -14,14 +14,14 @@ AllowShortLoopsOnASingleLine: true
 BreakBeforeBraces: Attach
 BreakBeforeBinaryOperators: None
 ColumnLimit: 90
-ExperimentalAutoDetectBinPacking: true
+ExperimentalAutoDetectBinPacking: false  # <--- safer default for .cu/.cuh
 FixNamespaceComments: true
 IndentWidth: 2
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-ReflowComments: true
+ReflowComments: IndentOnly
 PenaltyBreakComment: 1
-PenaltyBreakOpenParenthesis: 1  # modified; was 0
+PenaltyBreakOpenParenthesis: 1
 SortIncludes: CaseSensitive
 SortUsingDeclarations: true
 SpacesBeforeTrailingComments: 1
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -1,9 +1,10 @@
 repos:
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: 'v19.1.7'
+    rev: 'v20.1.8'
     hooks:
       - id: clang-format
         types_or: [c++, c, cuda]
+        files: \.(c|cc|h|hpp|cu|cuh)$
         exclude: '(^|/)(matlab/.*)$'
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v5.0.0
@@ -14,13 +15,19 @@ repos:
       - id: check-illegal-windows-names
       - id: mixed-line-ending
   - repo: https://github.com/BlankSpruce/gersemi
-    rev: 0.19.1
+    rev: 0.21.0
     hooks:
       - id: gersemi
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.23  # Use the latest stable version
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
         # Optional: Include additional validations from SchemaStore
         additional_dependencies: ["validate-pyproject-schema-store[all]"]
         files: ^python/(finufft|cufinufft)/pyproject\.toml$
+  - repo: https://github.com/LilSpazJoekp/docstrfmt
+    rev: v1.10.0
+    hooks:
+      - id: docstrfmt
+        language_version: python3
+        types_or: [rst] # only needed if you want to include txt files.
diff --git a/include/cufinufft/impl.h b/include/cufinufft/impl.h
@@ -707,8 +707,7 @@ int cufinufft_setpts_impl(int M, T *d_kx, T *d_ky, T *d_kz, int N, T *d_s, T *d_
                                   d_plan->spopts);
     if (d_plan->dim > 1) {
       onedim_nuft_kernel_precomp<T>(nuft_precomp_f.data() + MAX_NQUAD,
-                                    nuft_precomp_z.data() + MAX_NQUAD,
-                                    d_plan->spopts);
+                                    nuft_precomp_z.data() + MAX_NQUAD, d_plan->spopts);
     }
     if (d_plan->dim > 2) {
       onedim_nuft_kernel_precomp<T>(nuft_precomp_f.data() + 2 * MAX_NQUAD,
@@ -765,8 +764,8 @@ int cufinufft_setpts_impl(int M, T *d_kx, T *d_ky, T *d_kz, int N, T *d_s, T *d_
           thrust::cuda::par.on(stream), phase_iterator, phase_iterator + N,
           d_plan->deconv, d_plan->deconv,
           [c1, c2, c3, d1, d2, d3, realsign] __host__
-          __device__(const thrust::tuple<T, T, T> tuple, cuda_complex<T> deconv)
-          -> cuda_complex<T> {
+          __device__(const thrust::tuple<T, T, T> tuple,
+                     cuda_complex<T> deconv) -> cuda_complex<T> {
             // d2 and d3 are 0 if dim < 2 and dim < 3
             const auto phase = c1 * (thrust::get<0>(tuple) + d1) +
                                c2 * (thrust::get<1>(tuple) + d2) +
diff --git a/src/cuda/memtransfer_wrapper.cu b/src/cuda/memtransfer_wrapper.cu
@@ -52,10 +52,9 @@ int allocgpumem1d_plan(cufinufft_plan_t<T> *d_plan)
              cudaMallocWrapper(&d_plan->binstartpts, numbins * sizeof(int), stream,
                                d_plan->supports_pools))))
       goto finalize;
-    if ((ier = checkCudaErrors(cudaMallocWrapper(&d_plan->subprobstartpts,
-                                                 (numbins + 1) * sizeof(int),
-                                                 stream,
-                                                 d_plan->supports_pools))))
+    if ((ier = checkCudaErrors(
+             cudaMallocWrapper(&d_plan->subprobstartpts, (numbins + 1) * sizeof(int),
+                               stream, d_plan->supports_pools))))
       goto finalize;
   } break;
   default:
@@ -65,10 +64,8 @@ int allocgpumem1d_plan(cufinufft_plan_t<T> *d_plan)
 
   if (!d_plan->opts.gpu_spreadinterponly) {
     if ((ier = checkCudaErrors(
-             cudaMallocWrapper(&d_plan->fw,
-                               maxbatchsize * nf1 * sizeof(cuda_complex<T>),
-                               stream,
-                               d_plan->supports_pools))))
+             cudaMallocWrapper(&d_plan->fw, maxbatchsize * nf1 * sizeof(cuda_complex<T>),
+                               stream, d_plan->supports_pools))))
       goto finalize;
     if ((ier = checkCudaErrors(
              cudaMallocWrapper(&d_plan->fwkerhalf1, (nf1 / 2 + 1) * sizeof(T), stream,
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -95,9 +95,8 @@ function(add_tests_with_prec PREC REQ_TOL CHECK_TOL SUFFIX)
         COMMAND spreadinterp1d_test${SUFFIX} 1e3 1e3 ${REQ_TOL} 0 2 2.0 ${CHECK_TOL}
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
     )
-    
-    add_test(NAME run_adjointness_${PREC} COMMAND adjointness${SUFFIX} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 
+    add_test(NAME run_adjointness_${PREC} COMMAND adjointness${SUFFIX} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 endfunction()
 
 # use above function to actually add the tests, with certain requested and check
diff --git a/test/cuda/cufinufft3d_test.cu b/test/cuda/cufinufft3d_test.cu
@@ -256,20 +256,19 @@ int run_test(int method, int type, int N1, int N2, int N3, int M, T tol, T check
 
 int main(int argc, char *argv[]) {
   if (argc != 11) {
-    fprintf(stderr,
-            "Usage: cufinufft3d1_test method type N1 N2 N3 M tol checktol prec\n"
-            "Arguments:\n"
-            "  method: One of\n"
-            "    1: nupts driven,\n"
-            "    2: sub-problem, or\n"
-            "    4: block gather.\n"
-            "  type: Type of transform (1, 2, 3)"
-            "  N1, N2, N3: The size of the 3D array\n"
-            "  M: The number of non-uniform points\n"
-            "  tol: NUFFT tolerance\n"
-            "  checktol:  relative error to pass test\n"
-            "  prec:  'f' or 'd' (float/double)\n"
-            "  upsamplefac: upsampling factor\n");
+    fprintf(stderr, "Usage: cufinufft3d1_test method type N1 N2 N3 M tol checktol prec\n"
+                    "Arguments:\n"
+                    "  method: One of\n"
+                    "    1: nupts driven,\n"
+                    "    2: sub-problem, or\n"
+                    "    4: block gather.\n"
+                    "  type: Type of transform (1, 2, 3)"
+                    "  N1, N2, N3: The size of the 3D array\n"
+                    "  M: The number of non-uniform points\n"
+                    "  tol: NUFFT tolerance\n"
+                    "  checktol:  relative error to pass test\n"
+                    "  prec:  'f' or 'd' (float/double)\n"
+                    "  upsamplefac: upsampling factor\n");
     return 1;
   }
   const int method       = atoi(argv[1]);
diff --git a/test/utils/dirft1d.hpp b/test/utils/dirft1d.hpp
@@ -20,12 +20,8 @@ template<typename BIGINT,
          typename CArr, // cArr[j] yields Complex<FLT>
          typename FArr  // fArr[m] yields Complex<FLT>
          >
-void dirft1d1(const BIGINT nj,
-              const XArr &x,
-              const CArr &c,
-              const int iflag,
-              const BIGINT ms,
-              FArr &fArr) {
+void dirft1d1(const BIGINT nj, const XArr &x, const CArr &c, const int iflag,
+              const BIGINT ms, FArr &fArr) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
@@ -63,11 +59,7 @@ template<typename BIGINT,
          typename CArr, // cArr[j] yields Complex<FLT>
          typename FArr  // fArr[m] yields Complex<FLT>
          >
-void dirft1d2(const BIGINT nj,
-              const XArr &x,
-              CArr &c,
-              const int iflag,
-              const BIGINT ms,
+void dirft1d2(const BIGINT nj, const XArr &x, CArr &c, const int iflag, const BIGINT ms,
               const FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
@@ -107,13 +99,8 @@ template<typename BIGINT,
          typename SArr, // sArr[k] yields real FLT
          typename FArr  // fArr[k] yields Complex<FLT>
          >
-void dirft1d3(const BIGINT nj,
-              const XArr &x,
-              const CArr &c,
-              const int iflag,
-              const BIGINT nk,
-              const SArr &sArr,
-              FArr &f) {
+void dirft1d3(const BIGINT nj, const XArr &x, const CArr &c, const int iflag,
+              const BIGINT nk, const SArr &sArr, FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
diff --git a/test/utils/dirft2d.hpp b/test/utils/dirft2d.hpp
@@ -23,14 +23,8 @@ template<typename BIGINT,
          typename CArr,  // c[j]       → Complex<FLT>
          typename FArr   // f[m]       → Complex<FLT>
          >
-void dirft2d1(BIGINT nj,
-              const XYArr &x,
-              const XYArr &y,
-              const CArr &c,
-              int iflag,
-              BIGINT ms,
-              BIGINT mt,
-              FArr &f) {
+void dirft2d1(BIGINT nj, const XYArr &x, const XYArr &y, const CArr &c, int iflag,
+              BIGINT ms, BIGINT mt, FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
@@ -71,14 +65,8 @@ void dirft2d1(BIGINT nj,
 // exponential.
 // Uses winding trick.  Barnett 1/26/17
 template<typename BIGINT, typename XYArr, typename CArr, typename FArr>
-void dirft2d2(BIGINT nj,
-              const XYArr &x,
-              const XYArr &y,
-              CArr &c,
-              int iflag,
-              BIGINT ms,
-              BIGINT mt,
-              const FArr &f) {
+void dirft2d2(BIGINT nj, const XYArr &x, const XYArr &y, CArr &c, int iflag, BIGINT ms,
+              BIGINT mt, const FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
@@ -117,15 +105,8 @@ void dirft2d2(BIGINT nj,
 //  If iflag>0 the + sign is used, otherwise the - sign is used, in the
 //  exponential. Simple brute force.  Barnett 1/26/17
 template<typename BIGINT, typename XYArr, typename CArr, typename STArr, typename FArr>
-void dirft2d3(BIGINT nj,
-              const XYArr &x,
-              const XYArr &y,
-              const CArr &c,
-              int iflag,
-              BIGINT nk,
-              const STArr &s,
-              const STArr &t,
-              FArr &f) {
+void dirft2d3(BIGINT nj, const XYArr &x, const XYArr &y, const CArr &c, int iflag,
+              BIGINT nk, const STArr &s, const STArr &t, FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
diff --git a/test/utils/dirft3d.hpp b/test/utils/dirft3d.hpp
@@ -23,16 +23,8 @@ template<typename BIGINT,
          typename XYZArr, // x[j], y[j], z[j] → FLT
          typename CArr,   // c[j]             → Complex<FLT>
          typename FArr>   // f[m]             → Complex<FLT>
-void dirft3d1(BIGINT nj,
-              const XYZArr &x,
-              const XYZArr &y,
-              const XYZArr &z,
-              const CArr &c,
-              int iflag,
-              BIGINT ms,
-              BIGINT mt,
-              BIGINT mu,
-              FArr &f) {
+void dirft3d1(BIGINT nj, const XYZArr &x, const XYZArr &y, const XYZArr &z, const CArr &c,
+              int iflag, BIGINT ms, BIGINT mt, BIGINT mu, FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
@@ -85,16 +77,8 @@ void dirft3d1(BIGINT nj,
 // Uses winding trick.  Barnett 2/1/17
 // ------------------------------------------------------------
 template<typename BIGINT, typename XYZArr, typename CArr, typename FArr>
-void dirft3d2(BIGINT nj,
-              const XYZArr &x,
-              const XYZArr &y,
-              const XYZArr &z,
-              CArr &c,
-              int iflag,
-              BIGINT ms,
-              BIGINT mt,
-              BIGINT mu,
-              const FArr &f) {
+void dirft3d2(BIGINT nj, const XYZArr &x, const XYZArr &y, const XYZArr &z, CArr &c,
+              int iflag, BIGINT ms, BIGINT mt, BIGINT mu, const FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;
 
@@ -137,16 +121,8 @@ void dirft3d2(BIGINT nj,
 //   f[k] = Σ_j c[j] exp(i * iflag * (s[k] x[j] + t[k] y[j] + u[k] z[j]))
 // ------------------------------------------------------------
 template<typename BIGINT, typename XYZArr, typename CArr, typename STUArr, typename FArr>
-void dirft3d3(BIGINT nj,
-              const XYZArr &x,
-              const XYZArr &y,
-              const XYZArr &z,
-              const CArr &c,
-              int iflag,
-              BIGINT nk,
-              const STUArr &s,
-              const STUArr &t,
-              const STUArr &u,
+void dirft3d3(BIGINT nj, const XYZArr &x, const XYZArr &y, const XYZArr &z, const CArr &c,
+              int iflag, BIGINT nk, const STUArr &s, const STUArr &t, const STUArr &u,
               FArr &f) {
   using Complex = std::decay_t<decltype(c[0])>;
   using FLT     = typename Complex::value_type;

Original file line number	Diff line number	Diff line change
`@@ -95,9 +95,8 @@ function(add_tests_with_prec PREC REQ_TOL CHECK_TOL SUFFIX)`
`95`	`95`	`COMMAND spreadinterp1d_test${SUFFIX} 1e3 1e3 ${REQ_TOL} 0 2 2.0 ${CHECK_TOL}`
`96`	`96`	`WORKING_DIRECTORY ${CMAKE_BINARY_DIR}`
`97`	`97`	`)`
`98`		`-`
`99`		`- add_test(NAME run_adjointness_${PREC} COMMAND adjointness${SUFFIX} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})`
`100`	`98`
	`99`	`+ add_test(NAME run_adjointness_${PREC} COMMAND adjointness${SUFFIX} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})`
`101`	`100`	`endfunction()`
`102`	`101`
`103`	`102`	`# use above function to actually add the tests, with certain requested and check`