Release v1.1.1 (#63)

eth-cscs · Jan 19, 2025 · 34391bc · 34391bc
1 parent 0a0a08c
commit 34391bc
Show file tree

Hide file tree

Showing 9 changed files with 125 additions and 66 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18 FATAL_ERROR) # 3.18 for C++17
-project(SpFFT LANGUAGES CXX VERSION 1.1.0)
+project(SpFFT LANGUAGES CXX VERSION 1.1.1)
 set(SPFFT_SO_VERSION 1)
 set(SPFFT_VERSION ${PROJECT_VERSION})
 

diff --git a/include/spfft/grid_float.h b/include/spfft/grid_float.h
@@ -36,6 +36,8 @@
 #include <mpi.h>
 #endif
 
+#ifdef SPFFT_SINGLE_PRECISION
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -188,3 +190,5 @@ SPFFT_EXPORT SpfftError spfft_float_grid_communicator(SpfftFloatGrid grid, MPI_C
 #endif
 
 #endif
+
+#endif
diff --git a/include/spfft/multi_transform_float.h b/include/spfft/multi_transform_float.h
@@ -32,6 +32,8 @@
 #include "spfft/transform_float.h"
 #include "spfft/types.h"
 
+#ifdef SPFFT_SINGLE_PRECISION
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -99,3 +101,5 @@ SPFFT_EXPORT SpfftError spfft_float_multi_transform_backward_ptr(int numTransfor
 #endif
 
 #endif
+
+#endif
diff --git a/include/spfft/spfft.h b/include/spfft/spfft.h
@@ -31,6 +31,8 @@
 #include "spfft/config.h"
 #include "spfft/grid.h"
 #include "spfft/grid_float.h"
+#include "spfft/multi_transform.h"
+#include "spfft/multi_transform_float.h"
 #include "spfft/transform.h"
 #include "spfft/transform_float.h"
 

diff --git a/include/spfft/transform_float.h b/include/spfft/transform_float.h
@@ -37,6 +37,8 @@
 #include <mpi.h>
 #endif
 
+#ifdef SPFFT_SINGLE_PRECISION
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -353,3 +355,5 @@ SPFFT_EXPORT SpfftError spfft_float_transform_communicator(SpfftFloatTransform t
 #endif
 
 #endif
+
+#endif
diff --git a/src/spfft/multi_transform.cpp b/src/spfft/multi_transform.cpp
@@ -26,7 +26,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include "spfft/multi_transform.h"
+
+#include <algorithm>
 #include <vector>
+
 #include "spfft/config.h"
 #include "spfft/multi_transform.hpp"
 #include "spfft/multi_transform_internal.hpp"
@@ -37,27 +40,43 @@ namespace spfft {
 void multi_transform_forward(int numTransforms, Transform* transforms,
                              const SpfftProcessingUnitType* inputLocations,
                              double* const* outputPointers, const SpfftScalingType* scalingTypes) {
-  MultiTransformInternal<Transform>::forward(numTransforms, transforms, inputLocations,
+  std::vector<Transform*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](Transform& t) { return &t; });
+
+  MultiTransformInternal<Transform>::forward(numTransforms, transformPtrs.data(), inputLocations,
                                              outputPointers, scalingTypes);
 }
 
 void multi_transform_backward(int numTransforms, Transform* transforms,
                               const double* const* inputPointers,
                               const SpfftProcessingUnitType* outputLocations) {
-  MultiTransformInternal<Transform>::backward(numTransforms, transforms, inputPointers,
+  std::vector<Transform*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](Transform& t) { return &t; });
+
+  MultiTransformInternal<Transform>::backward(numTransforms, transformPtrs.data(), inputPointers,
                                               outputLocations);
 }
 
 void multi_transform_forward(int numTransforms, Transform* transforms,
                              const double* const* inputPointers, double* const* outputPointers,
                              const SpfftScalingType* scalingTypes) {
-  MultiTransformInternal<Transform>::forward(numTransforms, transforms, inputPointers,
+  std::vector<Transform*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](Transform& t) { return &t; });
+
+  MultiTransformInternal<Transform>::forward(numTransforms, transformPtrs.data(), inputPointers,
                                              outputPointers, scalingTypes);
 }
 
 void multi_transform_backward(int numTransforms, Transform* transforms,
                               const double* const* inputPointers, double* const* outputPointers) {
-  MultiTransformInternal<Transform>::backward(numTransforms, transforms, inputPointers,
+  std::vector<Transform*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](Transform& t) { return &t; });
+
+  MultiTransformInternal<Transform>::backward(numTransforms, transformPtrs.data(), inputPointers,
                                               outputPointers);
 }
 }  // namespace spfft
@@ -69,8 +88,9 @@ SpfftError spfft_multi_transform_forward(int numTransforms, SpfftTransform* tran
                                          double* const* outputPointers,
                                          const SpfftScalingType* scalingTypes) {
   try {
-    multi_transform_forward(numTransforms, reinterpret_cast<spfft::Transform*>(transforms),
-                            inputLocations, outputPointers, scalingTypes);
+    spfft::MultiTransformInternal<spfft::Transform>::forward(
+        numTransforms, reinterpret_cast<spfft::Transform**>(transforms), inputLocations,
+        outputPointers, scalingTypes);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -84,8 +104,9 @@ SpfftError spfft_multi_transform_forward_ptr(int numTransforms, SpfftTransform*
                                              double* const* outputPointers,
                                              const SpfftScalingType* scalingTypes) {
   try {
-    multi_transform_forward(numTransforms, reinterpret_cast<spfft::Transform*>(transforms),
-                            inputPointers, outputPointers, scalingTypes);
+    spfft::MultiTransformInternal<spfft::Transform>::forward(
+        numTransforms, reinterpret_cast<spfft::Transform**>(transforms), inputPointers,
+        outputPointers, scalingTypes);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -98,8 +119,9 @@ SpfftError spfft_multi_transform_backward(int numTransforms, SpfftTransform* tra
                                           const double* const* inputPointers,
                                           const SpfftProcessingUnitType* outputLocations) {
   try {
-    multi_transform_backward(numTransforms, reinterpret_cast<spfft::Transform*>(transforms),
-                             inputPointers, outputLocations);
+    spfft::MultiTransformInternal<spfft::Transform>::backward(
+        numTransforms, reinterpret_cast<spfft::Transform**>(transforms), inputPointers,
+        outputLocations);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -112,8 +134,9 @@ SpfftError spfft_multi_transform_backward_ptr(int numTransforms, SpfftTransform*
                                               const double* const* inputPointers,
                                               double* const* outputPointers) {
   try {
-    multi_transform_backward(numTransforms, reinterpret_cast<spfft::Transform*>(transforms),
-                             inputPointers, outputPointers);
+    spfft::MultiTransformInternal<spfft::Transform>::backward(
+        numTransforms, reinterpret_cast<spfft::Transform**>(transforms), inputPointers,
+        outputPointers);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {

diff --git a/src/spfft/multi_transform_float.cpp b/src/spfft/multi_transform_float.cpp
@@ -26,6 +26,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include "spfft/multi_transform_float.h"
+
+#include <algorithm>
+#include <vector>
+
 #include "spfft/config.h"
 #include "spfft/multi_transform_float.hpp"
 #include "spfft/multi_transform_internal.hpp"
@@ -38,28 +42,44 @@ namespace spfft {
 void multi_transform_forward(int numTransforms, TransformFloat* transforms,
                              const SpfftProcessingUnitType* inputLocations,
                              float* const* outputPointers, const SpfftScalingType* scalingTypes) {
-  MultiTransformInternal<TransformFloat>::forward(numTransforms, transforms, inputLocations,
-                                             outputPointers, scalingTypes);
+  std::vector<TransformFloat*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](TransformFloat& t) { return &t; });
+
+  MultiTransformInternal<TransformFloat>::forward(numTransforms, transformPtrs.data(),
+                                                  inputLocations, outputPointers, scalingTypes);
 }
 
 void multi_transform_backward(int numTransforms, TransformFloat* transforms,
                               const float* const* inputPointers,
                               const SpfftProcessingUnitType* outputLocations) {
-  MultiTransformInternal<TransformFloat>::backward(numTransforms, transforms, inputPointers,
-                                              outputLocations);
+  std::vector<TransformFloat*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](TransformFloat& t) { return &t; });
+
+  MultiTransformInternal<TransformFloat>::backward(numTransforms, transformPtrs.data(),
+                                                   inputPointers, outputLocations);
 }
 
 void multi_transform_forward(int numTransforms, TransformFloat* transforms,
                              const float* const* inputPointers, float* const* outputPointers,
                              const SpfftScalingType* scalingTypes) {
-  MultiTransformInternal<TransformFloat>::forward(numTransforms, transforms, inputPointers,
-                                             outputPointers, scalingTypes);
+  std::vector<TransformFloat*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](TransformFloat& t) { return &t; });
+
+  MultiTransformInternal<TransformFloat>::forward(numTransforms, transformPtrs.data(),
+                                                  inputPointers, outputPointers, scalingTypes);
 }
 
 void multi_transform_backward(int numTransforms, TransformFloat* transforms,
                               const float* const* inputPointers, float* const* outputPointers) {
-  MultiTransformInternal<TransformFloat>::backward(numTransforms, transforms, inputPointers,
-                                              outputPointers);
+  std::vector<TransformFloat*> transformPtrs(numTransforms);
+  std::transform(transforms, transforms + numTransforms, transformPtrs.begin(),
+                 [](TransformFloat& t) { return &t; });
+
+  MultiTransformInternal<TransformFloat>::backward(numTransforms, transformPtrs.data(),
+                                                   inputPointers, outputPointers);
 }
 
 #endif
@@ -73,8 +93,9 @@ SpfftError spfft_float_multi_transform_forward(int numTransforms, SpfftFloatTran
                                                float* const* outputPointers,
                                                const SpfftScalingType* scalingTypes) {
   try {
-    multi_transform_forward(numTransforms, reinterpret_cast<spfft::TransformFloat*>(transforms),
-                            inputLocations, outputPointers, scalingTypes);
+    spfft::MultiTransformInternal<spfft::TransformFloat>::forward(
+        numTransforms, reinterpret_cast<spfft::TransformFloat**>(transforms), inputLocations,
+        outputPointers, scalingTypes);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -89,8 +110,9 @@ SpfftError spfft_float_multi_transform_forward_ptr(int numTransforms,
                                                    float* const* outputPointers,
                                                    const SpfftScalingType* scalingTypes) {
   try {
-    multi_transform_forward(numTransforms, reinterpret_cast<spfft::TransformFloat*>(transforms),
-                            inputPointers, outputPointers, scalingTypes);
+    spfft::MultiTransformInternal<spfft::TransformFloat>::forward(
+        numTransforms, reinterpret_cast<spfft::TransformFloat**>(transforms), inputPointers,
+        outputPointers, scalingTypes);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -103,8 +125,9 @@ SpfftError spfft_float_multi_transform_backward(int numTransforms, SpfftFloatTra
                                                 const float* const* inputPointers,
                                                 const SpfftProcessingUnitType* outputLocations) {
   try {
-    multi_transform_backward(numTransforms, reinterpret_cast<spfft::TransformFloat*>(transforms),
-                             inputPointers, outputLocations);
+    spfft::MultiTransformInternal<spfft::TransformFloat>::backward(
+        numTransforms, reinterpret_cast<spfft::TransformFloat**>(transforms), inputPointers,
+        outputLocations);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {
@@ -118,8 +141,9 @@ SpfftError spfft_float_multi_transform_backward_ptr(int numTransforms,
                                                     const float* const* inputPointers,
                                                     float* const* outputPointers) {
   try {
-    multi_transform_backward(numTransforms, reinterpret_cast<spfft::TransformFloat*>(transforms),
-                             inputPointers, outputPointers);
+    spfft::MultiTransformInternal<spfft::TransformFloat>::backward(
+        numTransforms, reinterpret_cast<spfft::TransformFloat**>(transforms), inputPointers,
+        outputPointers);
   } catch (const spfft::GenericError& e) {
     return e.error_code();
   } catch (...) {