diff --git a/common/src/KokkosFFT_common_types.hpp b/common/src/KokkosFFT_common_types.hpp
new file mode 100644
index 00000000..4caa1235
--- /dev/null
+++ b/common/src/KokkosFFT_common_types.hpp
@@ -0,0 +1,24 @@
+#ifndef KOKKOSFFT_COMMON_TYPES_HPP
+#define KOKKOSFFT_COMMON_TYPES_HPP
+
+namespace KokkosFFT {
+// Define type to specify transform axis
+template <std::size_t DIM>
+using axis_type = std::array<int, DIM>;
+
+// Define type to specify new shape
+template <std::size_t DIM>
+using shape_type = std::array<std::size_t, DIM>;
+
+// Tag to specify when and how to normalize
+enum class Normalization { forward, backward, ortho, none };
+
+// Tag to specify FFT direction
+enum class Direction {
+  forward,
+  backward,
+};
+
+}  // namespace KokkosFFT
+
+#endif
\ No newline at end of file
diff --git a/common/src/KokkosFFT_layouts.hpp b/common/src/KokkosFFT_layouts.hpp
index 01c41c1e..b2bf9d71 100644
--- a/common/src/KokkosFFT_layouts.hpp
+++ b/common/src/KokkosFFT_layouts.hpp
@@ -5,7 +5,7 @@
 #include <tuple>
 #include <iostream>
 #include <numeric>
-#include "KokkosFFT_default_types.hpp"
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 #include "KokkosFFT_transpose.hpp"
 
diff --git a/common/src/KokkosFFT_normalization.hpp b/common/src/KokkosFFT_normalization.hpp
index e9e5e4cf..8b37af48 100644
--- a/common/src/KokkosFFT_normalization.hpp
+++ b/common/src/KokkosFFT_normalization.hpp
@@ -2,7 +2,7 @@
 #define KOKKOSFFT_NORMALIZATION_HPP
 
 #include <tuple>
-#include "KokkosFFT_default_types.hpp"
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 
 namespace KokkosFFT {
@@ -28,25 +28,27 @@ auto _coefficients(const ViewType& inout, Direction direction,
   [[maybe_unused]] bool to_normalize = false;
 
   switch (normalization) {
-    case Normalization::FORWARD:
-      if (direction == Direction::Forward) {
+    case Normalization::forward:
+      if (direction == Direction::forward) {
         coef = static_cast<value_type>(1) / static_cast<value_type>(fft_size);
         to_normalize = true;
       }
 
       break;
-    case Normalization::BACKWARD:
-      if (direction == Direction::Backward) {
+    case Normalization::backward:
+      if (direction == Direction::backward) {
         coef = static_cast<value_type>(1) / static_cast<value_type>(fft_size);
         to_normalize = true;
       }
 
       break;
-    case Normalization::ORTHO:
+    case Normalization::ortho:
       coef = static_cast<value_type>(1) /
              Kokkos::sqrt(static_cast<value_type>(fft_size));
       to_normalize = true;
 
+      break;
+    default:  // No normalization
       break;
   };
   return std::tuple<value_type, bool>({coef, to_normalize});
@@ -62,11 +64,12 @@ void normalize(const ExecutionSpace& exec_space, ViewType& inout,
 }
 
 inline auto swap_direction(Normalization normalization) {
-  Normalization new_direction = Normalization::FORWARD;
+  Normalization new_direction = Normalization::none;
   switch (normalization) {
-    case Normalization::FORWARD: new_direction = Normalization::BACKWARD; break;
-    case Normalization::BACKWARD: new_direction = Normalization::FORWARD; break;
-    case Normalization::ORTHO: new_direction = Normalization::ORTHO; break;
+    case Normalization::forward: new_direction = Normalization::backward; break;
+    case Normalization::backward: new_direction = Normalization::forward; break;
+    case Normalization::ortho: new_direction = Normalization::ortho; break;
+    default: break;
   };
   return new_direction;
 }
diff --git a/common/src/KokkosFFT_padding.hpp b/common/src/KokkosFFT_padding.hpp
index af6971e6..60a82c6d 100644
--- a/common/src/KokkosFFT_padding.hpp
+++ b/common/src/KokkosFFT_padding.hpp
@@ -2,7 +2,7 @@
 #define KOKKOSFFT_PADDING_HPP
 
 #include <tuple>
-#include "KokkosFFT_default_types.hpp"
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 
 namespace KokkosFFT {
diff --git a/common/src/KokkosFFT_transpose.hpp b/common/src/KokkosFFT_transpose.hpp
index 068baf84..eec98507 100644
--- a/common/src/KokkosFFT_transpose.hpp
+++ b/common/src/KokkosFFT_transpose.hpp
@@ -3,7 +3,7 @@
 
 #include <numeric>
 #include <tuple>
-#include "KokkosFFT_default_types.hpp"
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 
 namespace KokkosFFT {
diff --git a/common/unit_test/Test_Normalization.cpp b/common/unit_test/Test_Normalization.cpp
index 53c872fc..9ec19ba7 100644
--- a/common/unit_test/Test_Normalization.cpp
+++ b/common/unit_test/Test_Normalization.cpp
@@ -19,16 +19,16 @@ TEST(Normalization, Forward) {
 
   Kokkos::fence();
 
-  // Backward FFT with Forward Normalization -> Do nothing
+  // Backward FFT with forward Normalization -> Do nothing
   KokkosFFT::Impl::normalize(execution_space(), x,
-                             KokkosFFT::Impl::Direction::Backward,
-                             KokkosFFT::Normalization::FORWARD, len);
+                             KokkosFFT::Direction::backward,
+                             KokkosFFT::Normalization::forward, len);
   EXPECT_TRUE(allclose(x, ref_b, 1.e-5, 1.e-12));
 
-  // Forward FFT with Forward Normalization -> 1/N normalization
+  // Forward FFT with forward Normalization -> 1/N normalization
   KokkosFFT::Impl::normalize(execution_space(), x,
-                             KokkosFFT::Impl::Direction::Forward,
-                             KokkosFFT::Normalization::FORWARD, len);
+                             KokkosFFT::Direction::forward,
+                             KokkosFFT::Normalization::forward, len);
   EXPECT_TRUE(allclose(x, ref_f, 1.e-5, 1.e-12));
 }
 
@@ -47,16 +47,16 @@ TEST(Normalization, Backward) {
 
   Kokkos::fence();
 
-  // Forward FFT with Backward Normalization -> Do nothing
+  // Forward FFT with backward Normalization -> Do nothing
   KokkosFFT::Impl::normalize(execution_space(), x,
-                             KokkosFFT::Impl::Direction::Forward,
-                             KokkosFFT::Normalization::BACKWARD, len);
+                             KokkosFFT::Direction::forward,
+                             KokkosFFT::Normalization::backward, len);
   EXPECT_TRUE(allclose(x, ref_f, 1.e-5, 1.e-12));
 
-  // Backward FFT with Backward Normalization -> 1/N normalization
+  // Backward FFT with backward Normalization -> 1/N normalization
   KokkosFFT::Impl::normalize(execution_space(), x,
-                             KokkosFFT::Impl::Direction::Backward,
-                             KokkosFFT::Normalization::BACKWARD, len);
+                             KokkosFFT::Direction::backward,
+                             KokkosFFT::Normalization::backward, len);
   EXPECT_TRUE(allclose(x, ref_b, 1.e-5, 1.e-12));
 }
 
@@ -78,15 +78,42 @@ TEST(Normalization, Ortho) {
 
   Kokkos::fence();
 
-  // Forward FFT with Ortho Normalization -> 1 / sqrt(N) normalization
+  // Forward FFT with ortho Normalization -> 1 / sqrt(N) normalization
   KokkosFFT::Impl::normalize(execution_space(), x_f,
-                             KokkosFFT::Impl::Direction::Forward,
-                             KokkosFFT::Normalization::ORTHO, len);
+                             KokkosFFT::Direction::forward,
+                             KokkosFFT::Normalization::ortho, len);
   EXPECT_TRUE(allclose(x_f, ref_f, 1.e-5, 1.e-12));
 
-  // Backward FFT with Ortho Normalization -> 1 / sqrt(N) normalization
+  // Backward FFT with ortho Normalization -> 1 / sqrt(N) normalization
   KokkosFFT::Impl::normalize(execution_space(), x_b,
-                             KokkosFFT::Impl::Direction::Backward,
-                             KokkosFFT::Normalization::ORTHO, len);
+                             KokkosFFT::Direction::backward,
+                             KokkosFFT::Normalization::ortho, len);
+  EXPECT_TRUE(allclose(x_b, ref_b, 1.e-5, 1.e-12));
+}
+
+TEST(Normalization, None) {
+  const int len = 30;
+  View1D<double> x_f("x_f", len), x_b("x_b", len);
+  View1D<double> ref_f("ref_f", len), ref_b("ref_b", len);
+
+  Kokkos::Random_XorShift64_Pool<> random_pool(/*seed=*/12345);
+  Kokkos::fill_random(x_f, random_pool, 1.0);
+
+  Kokkos::deep_copy(x_b, x_f);
+  Kokkos::deep_copy(ref_f, x_f);
+  Kokkos::deep_copy(ref_b, x_f);
+
+  Kokkos::fence();
+
+  // Forward FFT with none Normalization -> Do nothing
+  KokkosFFT::Impl::normalize(execution_space(), x_f,
+                             KokkosFFT::Direction::forward,
+                             KokkosFFT::Normalization::none, len);
+  EXPECT_TRUE(allclose(x_f, ref_f, 1.e-5, 1.e-12));
+
+  // Backward FFT with none Normalization -> Do nothing
+  KokkosFFT::Impl::normalize(execution_space(), x_b,
+                             KokkosFFT::Direction::backward,
+                             KokkosFFT::Normalization::none, len);
   EXPECT_TRUE(allclose(x_b, ref_b, 1.e-5, 1.e-12));
 }
\ No newline at end of file
diff --git a/examples/04_batchedFFT/04_batchedFFT.cpp b/examples/04_batchedFFT/04_batchedFFT.cpp
index afa23ada..ee731959 100644
--- a/examples/04_batchedFFT/04_batchedFFT.cpp
+++ b/examples/04_batchedFFT/04_batchedFFT.cpp
@@ -22,9 +22,9 @@ int main(int argc, char* argv[]) {
     Kokkos::fill_random(xc2c, random_pool, I);
 
     KokkosFFT::fft(execution_space(), xc2c, xc2c_hat,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/-1);
+                   KokkosFFT::Normalization::backward, /*axis=*/-1);
     KokkosFFT::ifft(execution_space(), xc2c_hat, xc2c_inv,
-                    KokkosFFT::Normalization::BACKWARD, /*axis=*/-1);
+                    KokkosFFT::Normalization::backward, /*axis=*/-1);
 
     // 1D batched R2C FFT
     View3D<double> xr2c("xr2c", n0, n1, n2);
@@ -32,7 +32,7 @@ int main(int argc, char* argv[]) {
     Kokkos::fill_random(xr2c, random_pool, 1);
 
     KokkosFFT::rfft(execution_space(), xr2c, xr2c_hat,
-                    KokkosFFT::Normalization::BACKWARD, /*axis=*/-1);
+                    KokkosFFT::Normalization::backward, /*axis=*/-1);
 
     // 1D batched C2R FFT
     View3D<Kokkos::complex<double> > xc2r("xr2c_hat", n0, n1, n2 / 2 + 1);
@@ -40,7 +40,7 @@ int main(int argc, char* argv[]) {
     Kokkos::fill_random(xc2r, random_pool, I);
 
     KokkosFFT::irfft(execution_space(), xc2r, xc2r_hat,
-                     KokkosFFT::Normalization::BACKWARD, /*axis=*/-1);
+                     KokkosFFT::Normalization::backward, /*axis=*/-1);
   }
   Kokkos::finalize();
 
diff --git a/examples/06_1DFFT_reuse_plans/06_1DFFT_reuse_plans.cpp b/examples/06_1DFFT_reuse_plans/06_1DFFT_reuse_plans.cpp
index 12d810e8..2bbaa44d 100644
--- a/examples/06_1DFFT_reuse_plans/06_1DFFT_reuse_plans.cpp
+++ b/examples/06_1DFFT_reuse_plans/06_1DFFT_reuse_plans.cpp
@@ -23,11 +23,11 @@ int main(int argc, char* argv[]) {
 
     int axis = -1;
     KokkosFFT::Impl::Plan fft_plan(execution_space(), xc2c, xc2c_hat,
-                                   KokkosFFT::Impl::Direction::Forward, axis);
+                                   KokkosFFT::Direction::forward, axis);
     KokkosFFT::fft(execution_space(), xc2c, xc2c_hat, fft_plan);
 
     KokkosFFT::Impl::Plan ifft_plan(execution_space(), xc2c_hat, xc2c_inv,
-                                    KokkosFFT::Impl::Direction::Backward, axis);
+                                    KokkosFFT::Direction::backward, axis);
     KokkosFFT::ifft(execution_space(), xc2c_hat, xc2c_inv, ifft_plan);
 
     // 1D R2C FFT
@@ -36,7 +36,7 @@ int main(int argc, char* argv[]) {
     Kokkos::fill_random(xr2c, random_pool, 1);
 
     KokkosFFT::Impl::Plan rfft_plan(execution_space(), xr2c, xr2c_hat,
-                                    KokkosFFT::Impl::Direction::Forward, axis);
+                                    KokkosFFT::Direction::forward, axis);
     KokkosFFT::rfft(execution_space(), xr2c, xr2c_hat, rfft_plan);
 
     // 1D C2R FFT
@@ -45,8 +45,7 @@ int main(int argc, char* argv[]) {
     Kokkos::fill_random(xc2r, random_pool, I);
 
     KokkosFFT::Impl::Plan irfft_plan(execution_space(), xc2r, xc2r_hat,
-                                     KokkosFFT::Impl::Direction::Backward,
-                                     axis);
+                                     KokkosFFT::Direction::backward, axis);
     KokkosFFT::irfft(execution_space(), xc2r, xc2r_hat, irfft_plan);
   }
   Kokkos::finalize();
diff --git a/common/src/KokkosFFT_Cuda_types.hpp b/fft/src/KokkosFFT_Cuda_types.hpp
similarity index 97%
rename from common/src/KokkosFFT_Cuda_types.hpp
rename to fft/src/KokkosFFT_Cuda_types.hpp
index c6e577e6..76a3206f 100644
--- a/common/src/KokkosFFT_Cuda_types.hpp
+++ b/fft/src/KokkosFFT_Cuda_types.hpp
@@ -2,6 +2,7 @@
 #define KOKKOSFFT_CUDA_TYPES_HPP
 
 #include <cufft.h>
+#include "KokkosFFT_common_types.hpp"
 
 // Check the size of complex type
 static_assert(sizeof(cufftComplex) == sizeof(Kokkos::complex<float>));
@@ -22,11 +23,6 @@ static_assert(alignof(fftw_complex) <= alignof(Kokkos::complex<double>));
 
 namespace KokkosFFT {
 namespace Impl {
-enum class Direction {
-  Forward,
-  Backward,
-};
-
 using FFTDirectionType = int;
 
 #ifdef ENABLE_HOST_AND_DEVICE
@@ -140,7 +136,7 @@ auto direction_type(Direction direction) {
   static constexpr FFTDirectionType _BACKWARD =
       std::is_same_v<ExecutionSpace, Kokkos::Cuda> ? CUFFT_INVERSE
                                                    : FFTW_BACKWARD;
-  return direction == Direction::Forward ? _FORWARD : _BACKWARD;
+  return direction == Direction::forward ? _FORWARD : _BACKWARD;
 }
 #else
 template <typename ExecutionSpace>
@@ -198,7 +194,7 @@ struct transform_type<ExecutionSpace, Kokkos::complex<T1>,
 
 template <typename ExecutionSpace>
 auto direction_type(Direction direction) {
-  return direction == Direction::Forward ? CUFFT_FORWARD : CUFFT_INVERSE;
+  return direction == Direction::forward ? CUFFT_FORWARD : CUFFT_INVERSE;
 }
 #endif
 }  // namespace Impl
diff --git a/common/src/KokkosFFT_HIP_types.hpp b/fft/src/KokkosFFT_HIP_types.hpp
similarity index 97%
rename from common/src/KokkosFFT_HIP_types.hpp
rename to fft/src/KokkosFFT_HIP_types.hpp
index fe1fa574..f99bf6fc 100644
--- a/common/src/KokkosFFT_HIP_types.hpp
+++ b/fft/src/KokkosFFT_HIP_types.hpp
@@ -2,6 +2,7 @@
 #define KOKKOSFFT_HIP_TYPES_HPP
 
 #include <hipfft/hipfft.h>
+#include "KokkosFFT_common_types.hpp"
 
 // Check the size of complex type
 static_assert(sizeof(hipfftComplex) == sizeof(Kokkos::complex<float>));
@@ -22,11 +23,6 @@ static_assert(alignof(fftw_complex) <= alignof(Kokkos::complex<double>));
 
 namespace KokkosFFT {
 namespace Impl {
-enum class Direction {
-  Forward,
-  Backward,
-};
-
 using FFTDirectionType = int;
 
 #ifdef ENABLE_HOST_AND_DEVICE
@@ -140,7 +136,7 @@ auto direction_type(Direction direction) {
   static constexpr FFTDirectionType _BACKWARD =
       std::is_same_v<ExecutionSpace, Kokkos::HIP> ? HIPFFT_BACKWARD
                                                   : FFTW_BACKWARD;
-  return direction == Direction::Forward ? _FORWARD : _BACKWARD;
+  return direction == Direction::forward ? _FORWARD : _BACKWARD;
 }
 #else
 template <typename ExecutionSpace>
@@ -198,7 +194,7 @@ struct transform_type<ExecutionSpace, Kokkos::complex<T1>,
 
 template <typename ExecutionSpace>
 auto direction_type(Direction direction) {
-  return direction == Direction::Forward ? HIPFFT_FORWARD : HIPFFT_BACKWARD;
+  return direction == Direction::forward ? HIPFFT_FORWARD : HIPFFT_BACKWARD;
 }
 #endif
 }  // namespace Impl
diff --git a/common/src/KokkosFFT_OpenMP_types.hpp b/fft/src/KokkosFFT_OpenMP_types.hpp
similarity index 96%
rename from common/src/KokkosFFT_OpenMP_types.hpp
rename to fft/src/KokkosFFT_OpenMP_types.hpp
index b7f79721..0970a889 100644
--- a/common/src/KokkosFFT_OpenMP_types.hpp
+++ b/fft/src/KokkosFFT_OpenMP_types.hpp
@@ -2,6 +2,7 @@
 #define KOKKOSFFT_OPENMP_TYPES_HPP
 
 #include <fftw3.h>
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 
 // Check the size of complex type
@@ -13,11 +14,6 @@ static_assert(alignof(fftw_complex) <= alignof(Kokkos::complex<double>));
 
 namespace KokkosFFT {
 namespace Impl {
-enum class Direction {
-  Forward,
-  Backward,
-};
-
 enum class FFTWTransformType { R2C, D2Z, C2R, Z2D, C2C, Z2Z };
 
 template <typename ExecutionSpace>
@@ -86,7 +82,7 @@ struct transform_type<ExecutionSpace, Kokkos::complex<T1>,
 
 template <typename ExecutionSpace>
 auto direction_type(Direction direction) {
-  return direction == Direction::Forward ? FFTW_FORWARD : FFTW_BACKWARD;
+  return direction == Direction::forward ? FFTW_FORWARD : FFTW_BACKWARD;
 }
 }  // namespace Impl
 }  // namespace KokkosFFT
diff --git a/fft/src/KokkosFFT_Plans.hpp b/fft/src/KokkosFFT_Plans.hpp
index 1f2b7937..445ed0bf 100644
--- a/fft/src/KokkosFFT_Plans.hpp
+++ b/fft/src/KokkosFFT_Plans.hpp
@@ -13,13 +13,11 @@
 #include "KokkosFFT_utils.hpp"
 
 #if defined(KOKKOS_ENABLE_CUDA)
-using default_device = Kokkos::Cuda;
 #include "KokkosFFT_Cuda_plans.hpp"
 #ifdef ENABLE_HOST_AND_DEVICE
 #include "KokkosFFT_OpenMP_plans.hpp"
 #endif
 #elif defined(KOKKOS_ENABLE_HIP)
-using default_device = Kokkos::HIP;
 #include "KokkosFFT_HIP_plans.hpp"
 #ifdef ENABLE_HOST_AND_DEVICE
 #include "KokkosFFT_OpenMP_plans.hpp"
@@ -30,13 +28,10 @@ using default_device = Kokkos::HIP;
 #include "KokkosFFT_OpenMP_plans.hpp"
 #endif
 #elif defined(KOKKOS_ENABLE_OPENMP)
-using default_device = Kokkos::OpenMP;
 #include "KokkosFFT_OpenMP_plans.hpp"
 #elif defined(KOKKOS_ENABLE_THREADS)
-using default_device = Kokkos::Threads;
 #include "KokkosFFT_OpenMP_plans.hpp"
 #else
-using default_device = Kokkos::Serial;
 #include "KokkosFFT_OpenMP_plans.hpp"
 #endif
 
@@ -100,7 +95,7 @@ class Plan {
   axis_type<DIM> m_axes;
 
   //! directions of fft
-  KokkosFFT::Impl::Direction m_direction;
+  KokkosFFT::Direction m_direction;
 
   ///@{
   //! extents of input/output views
@@ -123,8 +118,7 @@ class Plan {
   /// \param axis [in] Axis over which FFT is performed
   //
   explicit Plan(const ExecutionSpace& exec_space, InViewType& in,
-                OutViewType& out, KokkosFFT::Impl::Direction direction,
-                int axis)
+                OutViewType& out, KokkosFFT::Direction direction, int axis)
       : m_fft_size(1), m_is_transpose_needed(false), m_direction(direction) {
     static_assert(Kokkos::is_view<InViewType>::value,
                   "Plan::Plan: InViewType is not a Kokkos::View.");
@@ -172,7 +166,7 @@ class Plan {
   /// \param axes [in] Axes over which FFT is performed
   //
   explicit Plan(const ExecutionSpace& exec_space, InViewType& in,
-                OutViewType& out, KokkosFFT::Impl::Direction direction,
+                OutViewType& out, KokkosFFT::Direction direction,
                 axis_type<DIM> axes)
       : m_fft_size(1),
         m_is_transpose_needed(false),
@@ -228,7 +222,7 @@ class Plan {
   template <typename ExecutionSpace2, typename InViewType2,
             typename OutViewType2>
   void good(const InViewType2& in, const OutViewType2& out,
-            KokkosFFT::Impl::Direction direction, axis_type<DIM> axes) const {
+            KokkosFFT::Direction direction, axis_type<DIM> axes) const {
     static_assert(std::is_same_v<ExecutionSpace2, execSpace>,
                   "Plan::good: Execution spaces for plan and "
                   "execution are not identical.");
diff --git a/common/src/KokkosFFT_SYCL_types.hpp b/fft/src/KokkosFFT_SYCL_types.hpp
similarity index 98%
rename from common/src/KokkosFFT_SYCL_types.hpp
rename to fft/src/KokkosFFT_SYCL_types.hpp
index ceae8969..e1668d68 100644
--- a/common/src/KokkosFFT_SYCL_types.hpp
+++ b/fft/src/KokkosFFT_SYCL_types.hpp
@@ -5,6 +5,7 @@
 #include <sycl/sycl.hpp>
 #include <mkl.h>
 #include <oneapi/mkl/dfti.hpp>
+#include "KokkosFFT_common_types.hpp"
 #include "KokkosFFT_utils.hpp"
 
 // Check the size of complex type
@@ -27,11 +28,6 @@ static_assert(alignof(fftw_complex) <= alignof(Kokkos::complex<double>));
 
 namespace KokkosFFT {
 namespace Impl {
-enum class Direction {
-  Forward,
-  Backward,
-};
-
 using FFTDirectionType                      = int;
 constexpr FFTDirectionType MKL_FFT_FORWARD  = 1;
 constexpr FFTDirectionType MKL_FFT_BACKWARD = -1;
@@ -176,7 +172,7 @@ auto direction_type(Direction direction) {
       std::is_same_v<ExecutionSpace, Kokkos::Experimental::SYCL>
           ? MKL_FFT_BACKWARD
           : FFTW_BACKWARD;
-  return direction == Direction::Forward ? _FORWARD : _BACKWARD;
+  return direction == Direction::forward ? _FORWARD : _BACKWARD;
 }
 #else
 template <typename ExecutionSpace>
@@ -234,7 +230,7 @@ struct FFTPlanType<ExecutionSpace, Kokkos::complex<T1>, Kokkos::complex<T2>> {
 
 template <typename ExecutionSpace>
 auto direction_type(Direction direction) {
-  return direction == Direction::Forward ? MKL_FFT_FORWARD : MKL_FFT_BACKWARD;
+  return direction == Direction::forward ? MKL_FFT_FORWARD : MKL_FFT_BACKWARD;
 }
 #endif
 }  // namespace Impl
diff --git a/fft/src/KokkosFFT_Transform.hpp b/fft/src/KokkosFFT_Transform.hpp
index c9e7be64..23f0642f 100644
--- a/fft/src/KokkosFFT_Transform.hpp
+++ b/fft/src/KokkosFFT_Transform.hpp
@@ -44,7 +44,7 @@ template <typename ExecutionSpace, typename PlanType, typename InViewType,
           typename OutViewType>
 void _fft(const ExecutionSpace& exec_space, PlanType& plan,
           const InViewType& in, OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD) {
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "_fft: InViewType is not a Kokkos::View.");
   static_assert(Kokkos::is_view<OutViewType>::value,
@@ -79,19 +79,17 @@ void _fft(const ExecutionSpace& exec_space, PlanType& plan,
   auto* odata = reinterpret_cast<typename KokkosFFT::Impl::fft_data_type<
       ExecutionSpace, out_value_type>::type*>(out.data());
 
-  auto forward =
-      direction_type<ExecutionSpace>(KokkosFFT::Impl::Direction::Forward);
+  auto forward = direction_type<ExecutionSpace>(KokkosFFT::Direction::forward);
   KokkosFFT::Impl::_exec(plan.plan(), idata, odata, forward);
-  KokkosFFT::Impl::normalize(exec_space, out,
-                             KokkosFFT::Impl::Direction::Forward, norm,
-                             plan.fft_size());
+  KokkosFFT::Impl::normalize(exec_space, out, KokkosFFT::Direction::forward,
+                             norm, plan.fft_size());
 }
 
 template <typename ExecutionSpace, typename PlanType, typename InViewType,
           typename OutViewType>
 void _ifft(const ExecutionSpace& exec_space, PlanType& plan,
            const InViewType& in, OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD) {
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "_ifft: InViewType is not a Kokkos::View.");
   static_assert(Kokkos::is_view<OutViewType>::value,
@@ -127,11 +125,10 @@ void _ifft(const ExecutionSpace& exec_space, PlanType& plan,
       ExecutionSpace, out_value_type>::type*>(out.data());
 
   auto backward =
-      direction_type<ExecutionSpace>(KokkosFFT::Impl::Direction::Backward);
+      direction_type<ExecutionSpace>(KokkosFFT::Direction::backward);
   KokkosFFT::Impl::_exec(plan.plan(), idata, odata, backward);
-  KokkosFFT::Impl::normalize(exec_space, out,
-                             KokkosFFT::Impl::Direction::Backward, norm,
-                             plan.fft_size());
+  KokkosFFT::Impl::normalize(exec_space, out, KokkosFFT::Direction::backward,
+                             norm, plan.fft_size());
 }
 }  // namespace Impl
 }  // namespace KokkosFFT
@@ -148,7 +145,7 @@ namespace KokkosFFT {
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void fft(const ExecutionSpace& exec_space, const InViewType& in,
          OutViewType& out,
-         KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+         KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
          int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fft: InViewType is not a Kokkos::View.");
@@ -190,7 +187,7 @@ void fft(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Forward, axis);
+                             KokkosFFT::Direction::forward, axis);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -220,7 +217,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void fft(const ExecutionSpace& exec_space, const InViewType& in,
          OutViewType& out, const PlanType& plan,
-         KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+         KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
          int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fft: InViewType is not a Kokkos::View.");
@@ -262,7 +259,7 @@ void fft(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Forward, axis_type<1>{axis});
+      _in, out, KokkosFFT::Direction::forward, axis_type<1>{axis});
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -291,7 +288,7 @@ void fft(const ExecutionSpace& exec_space, const InViewType& in,
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void ifft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifft: InViewType is not a Kokkos::View.");
@@ -335,7 +332,7 @@ void ifft(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Backward, axis);
+                             KokkosFFT::Direction::backward, axis);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -365,7 +362,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void ifft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, const PlanType& plan,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifft: InViewType is not a Kokkos::View.");
@@ -409,7 +406,7 @@ void ifft(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Backward, axis_type<1>{axis});
+      _in, out, KokkosFFT::Direction::backward, axis_type<1>{axis});
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -438,7 +435,7 @@ void ifft(const ExecutionSpace& exec_space, const InViewType& in,
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void rfft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfft: InViewType is not a Kokkos::View.");
@@ -489,7 +486,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void rfft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, const PlanType& plan,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfft: InViewType is not a Kokkos::View.");
@@ -538,7 +535,7 @@ void rfft(const ExecutionSpace& exec_space, const InViewType& in,
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void irfft(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfft: InViewType is not a Kokkos::View.");
@@ -593,7 +590,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void irfft(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfft: InViewType is not a Kokkos::View.");
@@ -642,7 +639,7 @@ void irfft(const ExecutionSpace& exec_space, const InViewType& in,
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void hfft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "hfft: InViewType is not a Kokkos::View.");
@@ -701,7 +698,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void hfft(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, const PlanType& plan,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "hfft: InViewType is not a Kokkos::View.");
@@ -757,7 +754,7 @@ void hfft(const ExecutionSpace& exec_space, const InViewType& in,
 template <typename ExecutionSpace, typename InViewType, typename OutViewType>
 void ihfft(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ihfft: InViewType is not a Kokkos::View.");
@@ -811,7 +808,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType>
 void ihfft(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            int axis = -1, std::optional<std::size_t> n = std::nullopt) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ihfft: InViewType is not a Kokkos::View.");
@@ -866,7 +863,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void fft2(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fft2: InViewType is not a Kokkos::View.");
@@ -907,7 +904,7 @@ void fft2(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Forward, axes);
+                             KokkosFFT::Direction::forward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -936,7 +933,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM = 1>
 void fft2(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, const PlanType& plan,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fft2: InViewType is not a Kokkos::View.");
@@ -977,7 +974,7 @@ void fft2(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Forward, axes);
+      _in, out, KokkosFFT::Direction::forward, axes);
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -1006,7 +1003,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void ifft2(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifft2: InViewType is not a Kokkos::View.");
@@ -1047,7 +1044,7 @@ void ifft2(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Backward, axes);
+                             KokkosFFT::Direction::backward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -1076,7 +1073,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM = 1>
 void ifft2(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifft2: InViewType is not a Kokkos::View.");
@@ -1117,7 +1114,7 @@ void ifft2(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Backward, axes);
+      _in, out, KokkosFFT::Direction::backward, axes);
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -1146,7 +1143,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void rfft2(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfft2: InViewType is not a Kokkos::View.");
@@ -1197,7 +1194,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM = 1>
 void rfft2(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfft2: InViewType is not a Kokkos::View.");
@@ -1247,7 +1244,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void irfft2(const ExecutionSpace& exec_space, const InViewType& in,
             OutViewType& out,
-            KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+            KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
             axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfft2: InViewType is not a Kokkos::View.");
@@ -1307,7 +1304,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM = 1>
 void irfft2(const ExecutionSpace& exec_space, const InViewType& in,
             OutViewType& out, const PlanType& plan,
-            KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+            KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
             axis_type<2> axes = {-2, -1}, shape_type<DIM> s = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfft2: InViewType is not a Kokkos::View.");
@@ -1367,7 +1364,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void fftn(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           shape_type<DIM> s             = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fftn: InViewType is not a Kokkos::View.");
@@ -1413,7 +1410,7 @@ void fftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Forward, axes);
+                             KokkosFFT::Direction::forward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -1441,7 +1438,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void fftn(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, axis_type<DIM1> axes,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fftn: InViewType is not a Kokkos::View.");
@@ -1482,7 +1479,7 @@ void fftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Forward, axes);
+                             KokkosFFT::Direction::forward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -1511,7 +1508,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void fftn(const ExecutionSpace& exec_space, const InViewType& in,
           OutViewType& out, const PlanType& plan, axis_type<DIM1> axes,
-          KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+          KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
           shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "fftn: InViewType is not a Kokkos::View.");
@@ -1552,7 +1549,7 @@ void fftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Forward, axes);
+      _in, out, KokkosFFT::Direction::forward, axes);
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -1580,7 +1577,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM> s             = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifftn: InViewType is not a Kokkos::View.");
@@ -1626,7 +1623,7 @@ void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Backward, axes);
+                             KokkosFFT::Direction::backward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -1654,7 +1651,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, axis_type<DIM1> axes,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifftn: InViewType is not a Kokkos::View.");
@@ -1695,7 +1692,7 @@ void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   KokkosFFT::Impl::Plan plan(exec_space, _in, out,
-                             KokkosFFT::Impl::Direction::Backward, axes);
+                             KokkosFFT::Direction::backward, axes);
   if (plan.is_transpose_needed()) {
     InViewType in_T;
     OutViewType out_T;
@@ -1724,7 +1721,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan, axis_type<DIM1> axes,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "ifftn: InViewType is not a Kokkos::View.");
@@ -1765,7 +1762,7 @@ void ifftn(const ExecutionSpace& exec_space, const InViewType& in,
   }
 
   plan.template good<ExecutionSpace, InViewType, OutViewType>(
-      _in, out, KokkosFFT::Impl::Direction::Backward, axes);
+      _in, out, KokkosFFT::Direction::backward, axes);
 
   if (plan.is_transpose_needed()) {
     InViewType in_T;
@@ -1793,7 +1790,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void rfftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM> s             = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfftn: InViewType is not a Kokkos::View.");
@@ -1844,7 +1841,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void rfftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, const PlanType& plan, axis_type<DIM1> axes,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfftn: InViewType is not a Kokkos::View.");
@@ -1894,7 +1891,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void rfftn(const ExecutionSpace& exec_space, const InViewType& in,
            OutViewType& out, axis_type<DIM1> axes,
-           KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+           KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
            shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "rfftn: InViewType is not a Kokkos::View.");
@@ -1943,7 +1940,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM = 1>
 void irfftn(const ExecutionSpace& exec_space, const InViewType& in,
             OutViewType& out,
-            KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+            KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
             shape_type<DIM> s             = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfftn: InViewType is not a Kokkos::View.");
@@ -2002,7 +1999,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void irfftn(const ExecutionSpace& exec_space, const InViewType& in,
             OutViewType& out, axis_type<DIM1> axes,
-            KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+            KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
             shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfftn: InViewType is not a Kokkos::View.");
@@ -2062,7 +2059,7 @@ template <typename ExecutionSpace, typename InViewType, typename OutViewType,
           typename PlanType, std::size_t DIM1 = 1, std::size_t DIM2 = 1>
 void irfftn(const ExecutionSpace& exec_space, const InViewType& in,
             OutViewType& out, const PlanType& plan, axis_type<DIM1> axes,
-            KokkosFFT::Normalization norm = KokkosFFT::Normalization::BACKWARD,
+            KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward,
             shape_type<DIM2> s            = {0}) {
   static_assert(Kokkos::is_view<InViewType>::value,
                 "irfftn: InViewType is not a Kokkos::View.");
diff --git a/common/src/KokkosFFT_default_types.hpp b/fft/src/KokkosFFT_default_types.hpp
similarity index 70%
rename from common/src/KokkosFFT_default_types.hpp
rename to fft/src/KokkosFFT_default_types.hpp
index 0eb0c796..c67248c5 100644
--- a/common/src/KokkosFFT_default_types.hpp
+++ b/fft/src/KokkosFFT_default_types.hpp
@@ -4,38 +4,21 @@
 #include <Kokkos_Core.hpp>
 
 #if defined(KOKKOS_ENABLE_CUDA)
-using default_device = Kokkos::Cuda;
 #include "KokkosFFT_Cuda_types.hpp"
 #elif defined(KOKKOS_ENABLE_HIP)
-using default_device = Kokkos::HIP;
 #include "KokkosFFT_HIP_types.hpp"
 #elif defined(KOKKOS_ENABLE_SYCL)
 #include "KokkosFFT_SYCL_types.hpp"
 #elif defined(KOKKOS_ENABLE_OPENMP)
-using default_device = Kokkos::OpenMP;
 #include "KokkosFFT_OpenMP_types.hpp"
 #elif defined(KOKKOS_ENABLE_THREADS)
-using default_device = Kokkos::Threads;
 #include "KokkosFFT_OpenMP_types.hpp"
 #else
-using default_device = Kokkos::Serial;
 #include "KokkosFFT_OpenMP_types.hpp"
 #endif
 
 #include "KokkosFFT_utils.hpp"
 
-namespace KokkosFFT {
-// Define type to specify transform axis
-template <std::size_t DIM>
-using axis_type = std::array<int, DIM>;
-
-// Define type to specify new shape
-template <std::size_t DIM>
-using shape_type = std::array<std::size_t, DIM>;
-
-enum class Normalization { FORWARD, BACKWARD, ORTHO };
-}  // namespace KokkosFFT
-
 namespace KokkosFFT {
 namespace Impl {
 // Define fft data types
diff --git a/fft/unit_test/Test_Plans.cpp b/fft/unit_test/Test_Plans.cpp
index 197ff67d..0bf4987d 100644
--- a/fft/unit_test/Test_Plans.cpp
+++ b/fft/unit_test/Test_Plans.cpp
@@ -47,26 +47,26 @@ void test_plan_1dfft_1dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axis_0(execution_space(), x, x_c,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/0);
   KokkosFFT::Impl::Plan plan_r2c_axes_0(execution_space(), x, x_c,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axes=*/axes_type<1>({0}));
 
   // C2R plan
   KokkosFFT::Impl::Plan plan_c2r_axis0(execution_space(), x_c, x,
-                                       KokkosFFT::Impl::Direction::Backward,
+                                       KokkosFFT::Direction::backward,
                                        /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2r_axes0(execution_space(), x_c, x,
-                                       KokkosFFT::Impl::Direction::Backward,
+                                       KokkosFFT::Direction::backward,
                                        /*axes=*/axes_type<1>({0}));
 
   // C2C plan
   KokkosFFT::Impl::Plan plan_c2c_f_axis0(execution_space(), x_cin, x_cout,
-                                         KokkosFFT::Impl::Direction::Forward,
+                                         KokkosFFT::Direction::forward,
                                          /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2c_f_axes0(execution_space(), x_cin, x_cout,
-                                         KokkosFFT::Impl::Direction::Backward,
+                                         KokkosFFT::Direction::backward,
                                          /*axes=*/axes_type<1>({0}));
 }
 
@@ -83,32 +83,32 @@ void test_plan_1dfft_2dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axis_0(execution_space(), x, x_c_axis_0,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/0);
   KokkosFFT::Impl::Plan plan_r2c_axis_1(execution_space(), x, x_c_axis_1,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/1);
-  KokkosFFT::Impl::Plan plan_r2c_axis_minus1(
-      execution_space(), x, x_c_axis_1, KokkosFFT::Impl::Direction::Forward,
-      /*axis=*/-1);
+  KokkosFFT::Impl::Plan plan_r2c_axis_minus1(execution_space(), x, x_c_axis_1,
+                                             KokkosFFT::Direction::forward,
+                                             /*axis=*/-1);
 
   // C2R plan
   KokkosFFT::Impl::Plan plan_c2r_axis_0(execution_space(), x_c_axis_0, x,
-                                        KokkosFFT::Impl::Direction::Backward,
+                                        KokkosFFT::Direction::backward,
                                         /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2r_axis_1(execution_space(), x_c_axis_1, x,
-                                        KokkosFFT::Impl::Direction::Backward,
+                                        KokkosFFT::Direction::backward,
                                         /*axis=*/1);
-  KokkosFFT::Impl::Plan plan_c2r_axis_minus1(
-      execution_space(), x_c_axis_1, x, KokkosFFT::Impl::Direction::Backward,
-      /*axis=*/-1);
+  KokkosFFT::Impl::Plan plan_c2r_axis_minus1(execution_space(), x_c_axis_1, x,
+                                             KokkosFFT::Direction::backward,
+                                             /*axis=*/-1);
 
   // C2C plan
   KokkosFFT::Impl::Plan plan_c2c_f_axis_0(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2c_f_axis_1(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axis=*/1);
 }
 
@@ -127,44 +127,44 @@ void test_plan_1dfft_3dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axis_0(execution_space(), x, x_c_axis_0,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/0);
   KokkosFFT::Impl::Plan plan_r2c_axis_1(execution_space(), x, x_c_axis_1,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/1);
   KokkosFFT::Impl::Plan plan_r2c_axis_2(execution_space(), x, x_c_axis_2,
-                                        KokkosFFT::Impl::Direction::Forward,
+                                        KokkosFFT::Direction::forward,
                                         /*axis=*/2);
 
   // C2R plan
   KokkosFFT::Impl::Plan plan_c2r_axis_0(execution_space(), x_c_axis_0, x,
-                                        KokkosFFT::Impl::Direction::Backward,
+                                        KokkosFFT::Direction::backward,
                                         /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2r_axis_1(execution_space(), x_c_axis_1, x,
-                                        KokkosFFT::Impl::Direction::Backward,
+                                        KokkosFFT::Direction::backward,
                                         /*axis=*/1);
   KokkosFFT::Impl::Plan plan_c2r_axis_2(execution_space(), x_c_axis_2, x,
-                                        KokkosFFT::Impl::Direction::Backward,
+                                        KokkosFFT::Direction::backward,
                                         /*axis=*/2);
 
   // C2C plan
   KokkosFFT::Impl::Plan plan_c2c_f_axis_0(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2c_f_axis_1(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axis=*/1);
   KokkosFFT::Impl::Plan plan_c2c_f_axis_2(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axis=*/2);
   KokkosFFT::Impl::Plan plan_c2c_b_axis_0(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axis=*/0);
   KokkosFFT::Impl::Plan plan_c2c_b_axis_1(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axis=*/1);
   KokkosFFT::Impl::Plan plan_c2c_b_axis_2(execution_space(), x_cin, x_cout,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axis=*/2);
 }
 
@@ -206,26 +206,26 @@ void test_plan_2dfft_2dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axes_0_1(execution_space(), x, x_c_axis_1,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_r2c_axes_1_0(execution_space(), x, x_c_axis_0,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({1, 0}));
 
   // C2R plan
   KokkosFFT::Impl::Plan plan_c2r_axes_0_1(execution_space(), x_c_axis_1, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_c2r_axes_1_0(execution_space(), x_c_axis_0, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({1, 0}));
 
   // C2C plan
   KokkosFFT::Impl::Plan plan_c2c_f_axes_0_1(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_1_0(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({1, 0}));
 }
 
@@ -244,62 +244,62 @@ void test_plan_2dfft_3dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axes_0_1(execution_space(), x, x_c_axis_1,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_r2c_axes_0_2(execution_space(), x, x_c_axis_2,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({0, 2}));
   KokkosFFT::Impl::Plan plan_r2c_axes_1_0(execution_space(), x, x_c_axis_0,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({1, 0}));
   KokkosFFT::Impl::Plan plan_r2c_axes_1_2(execution_space(), x, x_c_axis_2,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({1, 2}));
   KokkosFFT::Impl::Plan plan_r2c_axes_2_0(execution_space(), x, x_c_axis_0,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({2, 0}));
   KokkosFFT::Impl::Plan plan_r2c_axes_2_1(execution_space(), x, x_c_axis_1,
-                                          KokkosFFT::Impl::Direction::Forward,
+                                          KokkosFFT::Direction::forward,
                                           /*axes=*/axes_type<2>({2, 1}));
 
   // C2R plan
   KokkosFFT::Impl::Plan plan_c2r_axes_0_1(execution_space(), x_c_axis_1, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_c2r_axes_0_2(execution_space(), x_c_axis_2, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({0, 2}));
   KokkosFFT::Impl::Plan plan_c2r_axes_1_0(execution_space(), x_c_axis_0, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({1, 0}));
   KokkosFFT::Impl::Plan plan_c2r_axes_1_2(execution_space(), x_c_axis_2, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({1, 2}));
   KokkosFFT::Impl::Plan plan_c2r_axes_2_0(execution_space(), x_c_axis_0, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({2, 0}));
   KokkosFFT::Impl::Plan plan_c2r_axes_2_1(execution_space(), x_c_axis_1, x,
-                                          KokkosFFT::Impl::Direction::Backward,
+                                          KokkosFFT::Direction::backward,
                                           /*axes=*/axes_type<2>({2, 1}));
 
   // C2C plan
   KokkosFFT::Impl::Plan plan_c2c_f_axes_0_1(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({0, 1}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_0_2(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({0, 2}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_1_0(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({1, 0}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_1_2(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({1, 2}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_2_0(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({2, 0}));
   KokkosFFT::Impl::Plan plan_c2c_f_axes_2_1(execution_space(), x_cin, x_cout,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<2>({2, 1}));
 }
 
@@ -335,63 +335,63 @@ void test_plan_3dfft_3dview() {
 
   // R2C plan
   KokkosFFT::Impl::Plan plan_r2c_axes_0_1_2(execution_space(), x, x_c_axis_2,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({0, 1, 2}));
   KokkosFFT::Impl::Plan plan_r2c_axes_0_2_1(execution_space(), x, x_c_axis_1,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({0, 2, 1}));
   KokkosFFT::Impl::Plan plan_r2c_axes_1_0_2(execution_space(), x, x_c_axis_2,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({1, 0, 2}));
   KokkosFFT::Impl::Plan plan_r2c_axes_1_2_0(execution_space(), x, x_c_axis_0,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({1, 2, 0}));
   KokkosFFT::Impl::Plan plan_r2c_axes_2_0_1(execution_space(), x, x_c_axis_1,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({2, 0, 1}));
   KokkosFFT::Impl::Plan plan_r2c_axes_2_1_0(execution_space(), x, x_c_axis_0,
-                                            KokkosFFT::Impl::Direction::Forward,
+                                            KokkosFFT::Direction::forward,
                                             /*axes=*/axes_type<3>({2, 1, 0}));
 
   // C2R plan
-  KokkosFFT::Impl::Plan plan_c2r_axes_0_1_2(
-      execution_space(), x_c_axis_2, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({0, 1, 2}));
-  KokkosFFT::Impl::Plan plan_c2r_axes_0_2_1(
-      execution_space(), x_c_axis_1, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({0, 2, 1}));
-  KokkosFFT::Impl::Plan plan_c2r_axes_1_0_2(
-      execution_space(), x_c_axis_2, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({1, 0, 2}));
-  KokkosFFT::Impl::Plan plan_c2r_axes_1_2_0(
-      execution_space(), x_c_axis_0, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({1, 2, 0}));
-  KokkosFFT::Impl::Plan plan_c2r_axes_2_0_1(
-      execution_space(), x_c_axis_1, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({2, 0, 1}));
-  KokkosFFT::Impl::Plan plan_c2r_axes_2_1_0(
-      execution_space(), x_c_axis_0, x, KokkosFFT::Impl::Direction::Backward,
-      /*axes=*/axes_type<3>({2, 1, 0}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_0_1_2(execution_space(), x_c_axis_2, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({0, 1, 2}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_0_2_1(execution_space(), x_c_axis_1, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({0, 2, 1}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_1_0_2(execution_space(), x_c_axis_2, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({1, 0, 2}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_1_2_0(execution_space(), x_c_axis_0, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({1, 2, 0}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_2_0_1(execution_space(), x_c_axis_1, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({2, 0, 1}));
+  KokkosFFT::Impl::Plan plan_c2r_axes_2_1_0(execution_space(), x_c_axis_0, x,
+                                            KokkosFFT::Direction::backward,
+                                            /*axes=*/axes_type<3>({2, 1, 0}));
 
   // C2C plan
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_0_1_2(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({0, 1, 2}));
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_0_2_1(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({0, 2, 1}));
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_1_0_2(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({1, 0, 2}));
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_1_2_0(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({1, 2, 0}));
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_2_0_1(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({2, 0, 1}));
-  KokkosFFT::Impl::Plan plan_c2c_f_axes_2_1_0(
-      execution_space(), x_cin, x_cout, KokkosFFT::Impl::Direction::Forward,
-      /*axes=*/axes_type<3>({2, 1, 0}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_0_1_2(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({0, 1, 2}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_0_2_1(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({0, 2, 1}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_1_0_2(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({1, 0, 2}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_1_2_0(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({1, 2, 0}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_2_0_1(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({2, 0, 1}));
+  KokkosFFT::Impl::Plan plan_c2c_f_axes_2_1_0(execution_space(), x_cin, x_cout,
+                                              KokkosFFT::Direction::forward,
+                                              /*axes=*/axes_type<3>({2, 1, 0}));
 }
 
 // Tests for 3D FFT plan on 3D View
diff --git a/fft/unit_test/Test_Transform.cpp b/fft/unit_test/Test_Transform.cpp
index 8b2edcdd..08fbe72a 100644
--- a/fft/unit_test/Test_Transform.cpp
+++ b/fft/unit_test/Test_Transform.cpp
@@ -168,20 +168,19 @@ void test_fft1_identity_reuse_plan(T atol = 1.0e-12) {
 
     int axis = -1;
     KokkosFFT::Impl::Plan fft_plan(execution_space(), a, out,
-                                   KokkosFFT::Impl::Direction::Forward, axis);
+                                   KokkosFFT::Direction::forward, axis);
     KokkosFFT::fft(execution_space(), a, out, fft_plan);
 
     KokkosFFT::Impl::Plan ifft_plan(execution_space(), out, _a,
-                                    KokkosFFT::Impl::Direction::Backward, axis);
+                                    KokkosFFT::Direction::backward, axis);
     KokkosFFT::ifft(execution_space(), out, _a, ifft_plan);
 
     KokkosFFT::Impl::Plan rfft_plan(execution_space(), ar, outr,
-                                    KokkosFFT::Impl::Direction::Forward, axis);
+                                    KokkosFFT::Direction::forward, axis);
     KokkosFFT::rfft(execution_space(), ar, outr, rfft_plan);
 
     KokkosFFT::Impl::Plan irfft_plan(execution_space(), outr, _ar,
-                                     KokkosFFT::Impl::Direction::Backward,
-                                     axis);
+                                     KokkosFFT::Direction::backward, axis);
     KokkosFFT::irfft(execution_space(), outr, _ar, irfft_plan);
 
     EXPECT_TRUE(allclose(_a, a_ref, 1.e-5, atol));
@@ -204,43 +203,41 @@ void test_fft1_identity_reuse_plan(T atol = 1.0e-12) {
   // Create correct plans
   int axis = -1;
   KokkosFFT::Impl::Plan fft_plan(execution_space(), a, out,
-                                 KokkosFFT::Impl::Direction::Forward, axis);
+                                 KokkosFFT::Direction::forward, axis);
 
   KokkosFFT::Impl::Plan ifft_plan(execution_space(), out, _a,
-                                  KokkosFFT::Impl::Direction::Backward, axis);
+                                  KokkosFFT::Direction::backward, axis);
 
   KokkosFFT::Impl::Plan rfft_plan(execution_space(), ar, outr,
-                                  KokkosFFT::Impl::Direction::Forward, axis);
+                                  KokkosFFT::Direction::forward, axis);
 
   KokkosFFT::Impl::Plan irfft_plan(execution_space(), outr, _ar,
-                                   KokkosFFT::Impl::Direction::Backward, axis);
+                                   KokkosFFT::Direction::backward, axis);
 
   // Check if errors are correctly raised aginst wrong axis
   int wrong_axis = 0;
   EXPECT_THROW(KokkosFFT::fft(execution_space(), a, out, fft_plan,
-                              KokkosFFT::Normalization::BACKWARD, wrong_axis),
+                              KokkosFFT::Normalization::backward, wrong_axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::ifft(execution_space(), out, _a, ifft_plan,
-                               KokkosFFT::Normalization::BACKWARD, wrong_axis),
+                               KokkosFFT::Normalization::backward, wrong_axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::rfft(execution_space(), ar, outr, rfft_plan,
-                               KokkosFFT::Normalization::BACKWARD, wrong_axis),
+                               KokkosFFT::Normalization::backward, wrong_axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::irfft(execution_space(), outr, _ar, irfft_plan,
-                                KokkosFFT::Normalization::BACKWARD, wrong_axis),
+                                KokkosFFT::Normalization::backward, wrong_axis),
                std::runtime_error);
 
   // Check if errors are correctly raised aginst wrong dirction
-  KokkosFFT::Impl::Direction wrong_fft_direction =
-      KokkosFFT::Impl::Direction::Backward;
+  KokkosFFT::Direction wrong_fft_direction = KokkosFFT::Direction::backward;
   KokkosFFT::Impl::Plan wrong_fft_plan(execution_space(), a, out,
                                        wrong_fft_direction, axis);
 
-  KokkosFFT::Impl::Direction wrong_ifft_direction =
-      KokkosFFT::Impl::Direction::Forward;
+  KokkosFFT::Direction wrong_ifft_direction = KokkosFFT::Direction::forward;
   KokkosFFT::Impl::Plan wrong_ifft_plan(execution_space(), out, _a,
                                         wrong_ifft_direction, axis);
 
@@ -250,19 +247,19 @@ void test_fft1_identity_reuse_plan(T atol = 1.0e-12) {
                                          wrong_ifft_direction, axis);
 
   EXPECT_THROW(KokkosFFT::fft(execution_space(), a, out, wrong_fft_plan,
-                              KokkosFFT::Normalization::BACKWARD, axis),
+                              KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::ifft(execution_space(), out, _a, wrong_ifft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::rfft(execution_space(), ar, outr, wrong_rfft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   EXPECT_THROW(KokkosFFT::irfft(execution_space(), outr, _ar, wrong_irfft_plan,
-                                KokkosFFT::Normalization::BACKWARD, axis),
+                                KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // Check if errors are correctly raised aginst wrong extents
@@ -275,45 +272,45 @@ void test_fft1_identity_reuse_plan(T atol = 1.0e-12) {
   // fft
   // With incorrect input shape
   EXPECT_THROW(KokkosFFT::fft(execution_space(), a_wrong, out, fft_plan,
-                              KokkosFFT::Normalization::BACKWARD, axis),
+                              KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // With incorrect output shape
   EXPECT_THROW(KokkosFFT::fft(execution_space(), a, out_wrong, fft_plan,
-                              KokkosFFT::Normalization::BACKWARD, axis),
+                              KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // ifft
   // With incorrect input shape
   EXPECT_THROW(KokkosFFT::ifft(execution_space(), out_wrong, _a, ifft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // With incorrect output shape
   EXPECT_THROW(KokkosFFT::ifft(execution_space(), out, _a_wrong, ifft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // rfft
   // With incorrect input shape
   EXPECT_THROW(KokkosFFT::rfft(execution_space(), ar_wrong, outr, rfft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // With incorrect output shape
   EXPECT_THROW(KokkosFFT::rfft(execution_space(), ar, out_wrong, rfft_plan,
-                               KokkosFFT::Normalization::BACKWARD, axis),
+                               KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // irfft
   // With incorrect input shape
   EXPECT_THROW(KokkosFFT::irfft(execution_space(), outr_wrong, _ar, irfft_plan,
-                                KokkosFFT::Normalization::BACKWARD, axis),
+                                KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 
   // With incorrect output shape
   EXPECT_THROW(KokkosFFT::irfft(execution_space(), outr, _ar_wrong, irfft_plan,
-                                KokkosFFT::Normalization::BACKWARD, axis),
+                                KokkosFFT::Normalization::backward, axis),
                std::runtime_error);
 }
 
@@ -334,12 +331,12 @@ void test_fft1_1dfft_1dview() {
   Kokkos::fence();
 
   KokkosFFT::fft(execution_space(), x,
-                 out);  // default: KokkosFFT::Normalization::BACKWARD
+                 out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fft(execution_space(), x, out_b,
-                 KokkosFFT::Normalization::BACKWARD);
-  KokkosFFT::fft(execution_space(), x, out_o, KokkosFFT::Normalization::ORTHO);
+                 KokkosFFT::Normalization::backward);
+  KokkosFFT::fft(execution_space(), x, out_o, KokkosFFT::Normalization::ortho);
   KokkosFFT::fft(execution_space(), x, out_f,
-                 KokkosFFT::Normalization::FORWARD);
+                 KokkosFFT::Normalization::forward);
 
   fft1(x, ref);
   multiply(out_o, sqrt(static_cast<T>(len)));
@@ -368,12 +365,12 @@ void test_fft1_1difft_1dview() {
   Kokkos::fence();
 
   KokkosFFT::ifft(execution_space(), x,
-                  out);  // default: KokkosFFT::Normalization::BACKWARD
+                  out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifft(execution_space(), x, out_b,
-                  KokkosFFT::Normalization::BACKWARD);
-  KokkosFFT::ifft(execution_space(), x, out_o, KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::backward);
+  KokkosFFT::ifft(execution_space(), x, out_o, KokkosFFT::Normalization::ortho);
   KokkosFFT::ifft(execution_space(), x, out_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   ifft1(x, ref);
   multiply(out_o, sqrt(static_cast<T>(len)));
@@ -430,19 +427,19 @@ void test_fft1_1dhfft_1dview() {
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm,
-                  out);  // default: KokkosFFT::Normalization::BACKWARD
+                  out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_b,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_o,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(len)));
   multiply(out_f, static_cast<T>(len));
@@ -457,20 +454,20 @@ void test_fft1_1dhfft_1dview() {
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::Impl::Plan hfft_plan(execution_space(), x_herm, out,
-                                  KokkosFFT::Impl::Direction::Backward, axis);
+                                  KokkosFFT::Direction::backward, axis);
   KokkosFFT::hfft(execution_space(), x_herm, out, hfft_plan);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_b, hfft_plan,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_o, hfft_plan,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out_f, hfft_plan,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(len)));
   multiply(out_f, static_cast<T>(len));
@@ -513,27 +510,27 @@ void test_fft1_1dihfft_1dview() {
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm,
-                  out1);  // default: KokkosFFT::Normalization::BACKWARD
+                  out1);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ihfft(execution_space(), out1,
-                   out2);  // default: KokkosFFT::Normalization::BACKWARD
+                   out2);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_b,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::ihfft(execution_space(), out1_b, out2_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_o,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::ihfft(execution_space(), out1_o, out2_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
   KokkosFFT::ihfft(execution_space(), out1_f, out2_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   EXPECT_TRUE(allclose(out2, x_herm_ref, 1.e-5, 1.e-6));
   EXPECT_TRUE(allclose(out2_b, x_herm_ref, 1.e-5, 1.e-6));
@@ -543,33 +540,33 @@ void test_fft1_1dihfft_1dview() {
   // Reuse plans
   int axis = -1;
   KokkosFFT::Impl::Plan hfft_plan(execution_space(), x_herm, out1,
-                                  KokkosFFT::Impl::Direction::Backward, axis);
+                                  KokkosFFT::Direction::backward, axis);
   KokkosFFT::Impl::Plan ihfft_plan(execution_space(), out1, out2,
-                                   KokkosFFT::Impl::Direction::Forward, axis);
+                                   KokkosFFT::Direction::forward, axis);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1,
-                  hfft_plan);  // default: KokkosFFT::Normalization::BACKWARD
+                  hfft_plan);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ihfft(execution_space(), out1, out2,
-                   ihfft_plan);  // default: KokkosFFT::Normalization::BACKWARD
+                   ihfft_plan);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_b, hfft_plan,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::ihfft(execution_space(), out1_b, out2_b, ihfft_plan,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_o, hfft_plan,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::ihfft(execution_space(), out1_o, out2_o, ihfft_plan,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x_herm, x_herm_ref);
   KokkosFFT::hfft(execution_space(), x_herm, out1_f, hfft_plan,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
   KokkosFFT::ihfft(execution_space(), out1_f, out2_f, ihfft_plan,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   EXPECT_TRUE(allclose(out2, x_herm_ref, 1.e-5, 1.e-6));
   EXPECT_TRUE(allclose(out2_b, x_herm_ref, 1.e-5, 1.e-6));
@@ -617,18 +614,18 @@ void test_fft1_1dfft_2dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis0,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(out_axis0, ref_out_axis0, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis0, x_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(x_axis0, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   KokkosFFT::irfft(execution_space(), outr_axis0, xr_axis0,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                   KokkosFFT::Normalization::backward, /*axis=*/0);
 
   EXPECT_TRUE(allclose(xr_axis0, ref_xr, 1.e-5, atol));
 
@@ -645,18 +642,18 @@ void test_fft1_1dfft_2dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis1,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                 KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(out_axis1, ref_out_axis1, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis1, x_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(x_axis1, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::irfft(execution_space(), outr_axis1, xr_axis1,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                   KokkosFFT::Normalization::backward, /*axis=*/1);
 
   EXPECT_TRUE(allclose(xr_axis1, ref_xr, 1.e-5, atol));
 }
@@ -708,18 +705,18 @@ void test_fft1_1dfft_3dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis0,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(out_axis0, ref_out_axis0, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis0, x_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(x_axis0, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   KokkosFFT::irfft(execution_space(), outr_axis0, xr_axis0,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                   KokkosFFT::Normalization::backward, /*axis=*/0);
 
   EXPECT_TRUE(allclose(xr_axis0, ref_xr, 1.e-5, atol));
 
@@ -738,18 +735,18 @@ void test_fft1_1dfft_3dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis1,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                 KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(out_axis1, ref_out_axis1, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis1, x_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(x_axis1, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::irfft(execution_space(), outr_axis1, xr_axis1,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                   KokkosFFT::Normalization::backward, /*axis=*/1);
 
   EXPECT_TRUE(allclose(xr_axis1, ref_xr, 1.e-5, atol));
 
@@ -768,18 +765,18 @@ void test_fft1_1dfft_3dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                 KokkosFFT::Normalization::backward, /*axis=*/2);
   EXPECT_TRUE(allclose(out_axis2, ref_out_axis2, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis2, x_axis2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   EXPECT_TRUE(allclose(x_axis2, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   KokkosFFT::irfft(execution_space(), outr_axis2, xr_axis2,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                   KokkosFFT::Normalization::backward, /*axis=*/2);
 
   EXPECT_TRUE(allclose(xr_axis2, ref_xr, 1.e-5, atol));
 }
@@ -839,18 +836,18 @@ void test_fft1_1dfft_4dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis0,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(out_axis0, ref_out_axis0, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis0, x_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   EXPECT_TRUE(allclose(x_axis0, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis0,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   KokkosFFT::irfft(execution_space(), outr_axis0, xr_axis0,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                   KokkosFFT::Normalization::backward, /*axis=*/0);
 
   EXPECT_TRUE(allclose(xr_axis0, ref_xr, 1.e-5, atol));
 
@@ -871,18 +868,18 @@ void test_fft1_1dfft_4dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis1,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                 KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(out_axis1, ref_out_axis1, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis1, x_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   EXPECT_TRUE(allclose(x_axis1, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::irfft(execution_space(), outr_axis1, xr_axis1,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                   KokkosFFT::Normalization::backward, /*axis=*/1);
 
   EXPECT_TRUE(allclose(xr_axis1, ref_xr, 1.e-5, atol));
 
@@ -903,18 +900,18 @@ void test_fft1_1dfft_4dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                 KokkosFFT::Normalization::backward, /*axis=*/2);
   EXPECT_TRUE(allclose(out_axis2, ref_out_axis2, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis2, x_axis2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   EXPECT_TRUE(allclose(x_axis2, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   KokkosFFT::irfft(execution_space(), outr_axis2, xr_axis2,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                   KokkosFFT::Normalization::backward, /*axis=*/2);
 
   EXPECT_TRUE(allclose(xr_axis2, ref_xr, 1.e-5, atol));
 
@@ -935,18 +932,18 @@ void test_fft1_1dfft_4dview(T atol = 1.e-12) {
   }
 
   KokkosFFT::fft(execution_space(), x, out_axis3,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/3);
+                 KokkosFFT::Normalization::backward, /*axis=*/3);
   EXPECT_TRUE(allclose(out_axis3, ref_out_axis3, 1.e-5, atol));
 
   KokkosFFT::ifft(execution_space(), out_axis3, x_axis3,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/3);
+                  KokkosFFT::Normalization::backward, /*axis=*/3);
   EXPECT_TRUE(allclose(x_axis3, ref_x, 1.e-5, atol));
 
   // Simple identity tests for r2c and c2r transforms
   KokkosFFT::rfft(execution_space(), xr, outr_axis3,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/3);
+                  KokkosFFT::Normalization::backward, /*axis=*/3);
   KokkosFFT::irfft(execution_space(), outr_axis3, xr_axis3,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/3);
+                   KokkosFFT::Normalization::backward, /*axis=*/3);
 
   EXPECT_TRUE(allclose(xr_axis3, ref_xr, 1.e-5, atol));
 }
@@ -988,16 +985,16 @@ void test_fft1_1dfft_5dview(T atol = 1.e-12) {
     // Along one axis
     // Simple identity tests
     KokkosFFT::fft(execution_space(), x, out,
-                   KokkosFFT::Normalization::BACKWARD, axis);
+                   KokkosFFT::Normalization::backward, axis);
     KokkosFFT::ifft(execution_space(), out, _x,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     EXPECT_TRUE(allclose(_x, ref_x, 1.e-5, atol));
 
     // Simple identity tests for r2c and c2r transforms
     KokkosFFT::rfft(execution_space(), xr, outr,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     KokkosFFT::irfft(execution_space(), outr, _xr,
-                     KokkosFFT::Normalization::BACKWARD, axis);
+                     KokkosFFT::Normalization::backward, axis);
 
     EXPECT_TRUE(allclose(_xr, ref_xr, 1.e-5, atol));
   }
@@ -1042,16 +1039,16 @@ void test_fft1_1dfft_6dview(T atol = 1.e-12) {
     // Along one axis
     // Simple identity tests
     KokkosFFT::fft(execution_space(), x, out,
-                   KokkosFFT::Normalization::BACKWARD, axis);
+                   KokkosFFT::Normalization::backward, axis);
     KokkosFFT::ifft(execution_space(), out, _x,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     EXPECT_TRUE(allclose(_x, ref_x, 1.e-5, atol));
 
     // Simple identity tests for r2c and c2r transforms
     KokkosFFT::rfft(execution_space(), xr, outr,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     KokkosFFT::irfft(execution_space(), outr, _xr,
-                     KokkosFFT::Normalization::BACKWARD, axis);
+                     KokkosFFT::Normalization::backward, axis);
 
     EXPECT_TRUE(allclose(_xr, ref_xr, 1.e-5, atol));
   }
@@ -1096,16 +1093,16 @@ void test_fft1_1dfft_7dview(T atol = 1.e-12) {
     // Along one axis
     // Simple identity tests
     KokkosFFT::fft(execution_space(), x, out,
-                   KokkosFFT::Normalization::BACKWARD, axis);
+                   KokkosFFT::Normalization::backward, axis);
     KokkosFFT::ifft(execution_space(), out, _x,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     EXPECT_TRUE(allclose(_x, ref_x, 1.e-5, atol));
 
     // Simple identity tests for r2c and c2r transforms
     KokkosFFT::rfft(execution_space(), xr, outr,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     KokkosFFT::irfft(execution_space(), outr, _xr,
-                     KokkosFFT::Normalization::BACKWARD, axis);
+                     KokkosFFT::Normalization::backward, axis);
 
     EXPECT_TRUE(allclose(_xr, ref_xr, 1.e-5, atol));
   }
@@ -1150,16 +1147,16 @@ void test_fft1_1dfft_8dview(T atol = 1.e-12) {
     // Along one axis
     // Simple identity tests
     KokkosFFT::fft(execution_space(), x, out,
-                   KokkosFFT::Normalization::BACKWARD, axis);
+                   KokkosFFT::Normalization::backward, axis);
     KokkosFFT::ifft(execution_space(), out, _x,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     EXPECT_TRUE(allclose(_x, ref_x, 1.e-5, atol));
 
     // Simple identity tests for r2c and c2r transforms
     KokkosFFT::rfft(execution_space(), xr, outr,
-                    KokkosFFT::Normalization::BACKWARD, axis);
+                    KokkosFFT::Normalization::backward, axis);
     KokkosFFT::irfft(execution_space(), outr, _xr,
-                     KokkosFFT::Normalization::BACKWARD, axis);
+                     KokkosFFT::Normalization::backward, axis);
 
     EXPECT_TRUE(allclose(_xr, ref_xr, 1.e-5, atol));
   }
@@ -1298,18 +1295,18 @@ void test_fft2_2dfft_2dview() {
   Kokkos::fence();
 
   // np.fft2 is identical to np.fft(np.fft(x, axis=1), axis=0)
-  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::BACKWARD,
+  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::backward,
                  /*axis=*/1);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::fft2(execution_space(), x,
-                  out);  // default: KokkosFFT::Normalization::BACKWARD
+                  out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fft2(execution_space(), x, out_b,
-                  KokkosFFT::Normalization::BACKWARD);
-  KokkosFFT::fft2(execution_space(), x, out_o, KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::backward);
+  KokkosFFT::fft2(execution_space(), x, out_o, KokkosFFT::Normalization::ortho);
   KokkosFFT::fft2(execution_space(), x, out_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1323,15 +1320,15 @@ void test_fft2_2dfft_2dview() {
   using axes_type = KokkosFFT::axis_type<2>;
   axes_type axes  = {-2, -1};
   KokkosFFT::Impl::Plan fft2_plan(execution_space(), x, out,
-                                  KokkosFFT::Impl::Direction::Forward, axes);
+                                  KokkosFFT::Direction::forward, axes);
   KokkosFFT::fft2(execution_space(), x, out,
-                  fft2_plan);  // default: KokkosFFT::Normalization::BACKWARD
+                  fft2_plan);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fft2(execution_space(), x, out_b, fft2_plan,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::fft2(execution_space(), x, out_o, fft2_plan,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::fft2(execution_space(), x, out_f, fft2_plan,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1362,18 +1359,18 @@ void test_fft2_2difft_2dview() {
 
   // np.ifft2 is identical to np.ifft(np.ifft(x, axis=1), axis=0)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::ifft(execution_space(), out1, out2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::ifft2(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifft2(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifft2(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifft2(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1387,16 +1384,16 @@ void test_fft2_2difft_2dview() {
   using axes_type = KokkosFFT::axis_type<2>;
   axes_type axes  = {-2, -1};
   KokkosFFT::Impl::Plan ifft2_plan(execution_space(), x, out,
-                                   KokkosFFT::Impl::Direction::Backward, axes);
+                                   KokkosFFT::Direction::backward, axes);
 
   KokkosFFT::ifft2(execution_space(), x, out,
-                   ifft2_plan);  // default: KokkosFFT::Normalization::BACKWARD
+                   ifft2_plan);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifft2(execution_space(), x, out_b, ifft2_plan,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifft2(execution_space(), x, out_o, ifft2_plan,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifft2(execution_space(), x, out_f, ifft2_plan,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1427,25 +1424,25 @@ void test_fft2_2drfft_2dview() {
 
   // np.rfft2 is identical to np.fft(np.rfft(x, axis=1), axis=0)
   KokkosFFT::rfft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1459,23 +1456,23 @@ void test_fft2_2drfft_2dview() {
   using axes_type = KokkosFFT::axis_type<2>;
   axes_type axes  = {-2, -1};
   KokkosFFT::Impl::Plan rfft2_plan(execution_space(), x, out,
-                                   KokkosFFT::Impl::Direction::Forward, axes);
+                                   KokkosFFT::Direction::forward, axes);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out,
-                   rfft2_plan);  // default: KokkosFFT::Normalization::BACKWARD
+                   rfft2_plan);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_b, rfft2_plan,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_o, rfft2_plan,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfft2(execution_space(), x, out_f, rfft2_plan,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1506,25 +1503,25 @@ void test_fft2_2dirfft_2dview() {
 
   // np.irfft2 is identical to np.irfft(np.ifft(x, axis=0), axis=1)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, 0);
+                  KokkosFFT::Normalization::backward, 0);
   KokkosFFT::irfft(execution_space(), out1, out2,
-                   KokkosFFT::Normalization::BACKWARD, 1);
+                   KokkosFFT::Normalization::backward, 1);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x,
-                    out);  // default: KokkosFFT::Normalization::BACKWARD
+                    out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_b,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_o,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_f,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1538,24 +1535,24 @@ void test_fft2_2dirfft_2dview() {
   using axes_type = KokkosFFT::axis_type<2>;
   axes_type axes  = {-2, -1};
   KokkosFFT::Impl::Plan irfft2_plan(execution_space(), x, out,
-                                    KokkosFFT::Impl::Direction::Backward, axes);
+                                    KokkosFFT::Direction::backward, axes);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(
       execution_space(), x, out,
-      irfft2_plan);  // default: KokkosFFT::Normalization::BACKWARD
+      irfft2_plan);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_b, irfft2_plan,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_o, irfft2_plan,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfft2(execution_space(), x, out_f, irfft2_plan,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1618,18 +1615,18 @@ void test_fftn_2dfft_2dview() {
   Kokkos::fence();
 
   // np.fftn for 2D array is identical to np.fft(np.fft(x, axis=1), axis=0)
-  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::BACKWARD,
+  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::backward,
                  /*axis=*/1);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::fftn(execution_space(), x,
-                  out);  // default: KokkosFFT::Normalization::BACKWARD
+                  out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fftn(execution_space(), x, out_b,
-                  KokkosFFT::Normalization::BACKWARD);
-  KokkosFFT::fftn(execution_space(), x, out_o, KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::backward);
+  KokkosFFT::fftn(execution_space(), x, out_o, KokkosFFT::Normalization::ortho);
   KokkosFFT::fftn(execution_space(), x, out_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1645,13 +1642,13 @@ void test_fftn_2dfft_2dview() {
   axes_type axes  = {-2, -1};
 
   KokkosFFT::fftn(execution_space(), x, out,
-                  axes);  // default: KokkosFFT::Normalization::BACKWARD
+                  axes);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fftn(execution_space(), x, out_b, axes,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::fftn(execution_space(), x, out_o, axes,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::fftn(execution_space(), x, out_f, axes,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1663,16 +1660,16 @@ void test_fftn_2dfft_2dview() {
 
   // Reuse plans
   KokkosFFT::Impl::Plan fftn_plan(execution_space(), x, out,
-                                  KokkosFFT::Impl::Direction::Forward, axes);
+                                  KokkosFFT::Direction::forward, axes);
 
   KokkosFFT::fftn(execution_space(), x, out, fftn_plan,
-                  axes);  // default: KokkosFFT::Normalization::BACKWARD
+                  axes);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fftn(execution_space(), x, out_b, fftn_plan, axes,
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::fftn(execution_space(), x, out_o, fftn_plan, axes,
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::fftn(execution_space(), x, out_f, fftn_plan, axes,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1703,20 +1700,20 @@ void test_fftn_3dfft_3dview(T atol = 1.0e-6) {
 
   // np.fftn for 3D array is identical to np.fft(np.fft(np.fft(x, axis=2),
   // axis=1), axis=0)
-  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::BACKWARD,
+  KokkosFFT::fft(execution_space(), x, out1, KokkosFFT::Normalization::backward,
                  /*axis=*/2);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                 KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::fft(execution_space(), out2, out3,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::fftn(execution_space(), x,
-                  out);  // default: KokkosFFT::Normalization::BACKWARD
+                  out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fftn(execution_space(), x, out_b,
-                  KokkosFFT::Normalization::BACKWARD);
-  KokkosFFT::fftn(execution_space(), x, out_o, KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::backward);
+  KokkosFFT::fftn(execution_space(), x, out_o, KokkosFFT::Normalization::ortho);
   KokkosFFT::fftn(execution_space(), x, out_f,
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, static_cast<T>(n0 * n1 * n2));
@@ -1733,13 +1730,13 @@ void test_fftn_3dfft_3dview(T atol = 1.0e-6) {
 
   KokkosFFT::fftn(
       execution_space(), x, out,
-      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::BACKWARD
+      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::backward
   KokkosFFT::fftn(execution_space(), x, out_b, axes_type{-3, -2, -1},
-                  KokkosFFT::Normalization::BACKWARD);
+                  KokkosFFT::Normalization::backward);
   KokkosFFT::fftn(execution_space(), x, out_o, axes_type{-3, -2, -1},
-                  KokkosFFT::Normalization::ORTHO);
+                  KokkosFFT::Normalization::ortho);
   KokkosFFT::fftn(execution_space(), x, out_f, axes_type{-3, -2, -1},
-                  KokkosFFT::Normalization::FORWARD);
+                  KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, static_cast<T>(n0 * n1 * n2));
@@ -1770,18 +1767,18 @@ void test_ifftn_2dfft_2dview() {
 
   // np.ifftn for 2D array is identical to np.ifft(np.ifft(x, axis=1), axis=0)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::ifft(execution_space(), out1, out2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::ifftn(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifftn(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifftn(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifftn(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1797,13 +1794,13 @@ void test_ifftn_2dfft_2dview() {
   axes_type axes  = {-2, -1};
 
   KokkosFFT::ifftn(execution_space(), x, out,
-                   axes);  // default: KokkosFFT::Normalization::BACKWARD
+                   axes);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifftn(execution_space(), x, out_b, axes,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifftn(execution_space(), x, out_o, axes,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifftn(execution_space(), x, out_f, axes,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1815,15 +1812,15 @@ void test_ifftn_2dfft_2dview() {
 
   // Reuse plans
   KokkosFFT::Impl::Plan ifftn_plan(execution_space(), x, out,
-                                   KokkosFFT::Impl::Direction::Backward, axes);
+                                   KokkosFFT::Direction::backward, axes);
   KokkosFFT::ifftn(execution_space(), x, out, ifftn_plan,
-                   axes);  // default: KokkosFFT::Normalization::BACKWARD
+                   axes);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifftn(execution_space(), x, out_b, ifftn_plan, axes,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifftn(execution_space(), x, out_o, ifftn_plan, axes,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifftn(execution_space(), x, out_f, ifftn_plan, axes,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -1855,20 +1852,20 @@ void test_ifftn_3dfft_3dview() {
   // np.ifftn for 3D array is identical to np.ifft(np.ifft(np.ifft(x, axis=2),
   // axis=1), axis=0)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   KokkosFFT::ifft(execution_space(), out1, out2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::ifft(execution_space(), out2, out3,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
 
   KokkosFFT::ifftn(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifftn(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifftn(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifftn(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1 * n2));
@@ -1885,13 +1882,13 @@ void test_ifftn_3dfft_3dview() {
 
   KokkosFFT::ifftn(
       execution_space(), x, out,
-      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::BACKWARD
+      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::backward
   KokkosFFT::ifftn(execution_space(), x, out_b, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
   KokkosFFT::ifftn(execution_space(), x, out_o, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
   KokkosFFT::ifftn(execution_space(), x, out_f, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1 * n2));
@@ -1922,25 +1919,25 @@ void test_rfftn_2dfft_2dview() {
 
   // np.rfftn for 2D array is identical to np.fft(np.rfft(x, axis=1), axis=0)
   KokkosFFT::rfft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1957,19 +1954,19 @@ void test_rfftn_2dfft_2dview() {
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out,
-                   axes);  // default: KokkosFFT::Normalization::BACKWARD
+                   axes);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_b, axes,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_o, axes,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_f, axes,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -1981,23 +1978,23 @@ void test_rfftn_2dfft_2dview() {
 
   // Reuse plans
   KokkosFFT::Impl::Plan rfftn_plan(execution_space(), x, out,
-                                   KokkosFFT::Impl::Direction::Forward, axes);
+                                   KokkosFFT::Direction::forward, axes);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out, rfftn_plan,
-                   axes);  // default: KokkosFFT::Normalization::BACKWARD
+                   axes);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_b, rfftn_plan, axes,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_o, rfftn_plan, axes,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_f, rfftn_plan, axes,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, static_cast<T>(n0 * n1));
@@ -2030,27 +2027,27 @@ void test_rfftn_3dfft_3dview() {
   // np.rfftn for 3D array is identical to np.fft(np.fft(np.rfft(x, axis=2),
   // axis=1), axis=0)
   KokkosFFT::rfft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                  KokkosFFT::Normalization::backward, /*axis=*/2);
   KokkosFFT::fft(execution_space(), out1, out2,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                 KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::fft(execution_space(), out2, out3,
-                 KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                 KokkosFFT::Normalization::backward, /*axis=*/0);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x,
-                   out);  // default: KokkosFFT::Normalization::BACKWARD
+                   out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_b,
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_o,
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_f,
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, static_cast<T>(n0 * n1 * n2));
@@ -2068,19 +2065,19 @@ void test_rfftn_3dfft_3dview() {
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(
       execution_space(), x, out,
-      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::BACKWARD
+      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_b, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::BACKWARD);
+                   KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_o, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::ORTHO);
+                   KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::rfftn(execution_space(), x, out_f, axes_type{-3, -2, -1},
-                   KokkosFFT::Normalization::FORWARD);
+                   KokkosFFT::Normalization::forward);
 
   multiply(out_o, sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, static_cast<T>(n0 * n1 * n2));
@@ -2111,25 +2108,25 @@ void test_irfftn_2dfft_2dview() {
 
   // np.irfftn for 2D array is identical to np.irfft(np.ifft(x, axis=0), axis=1)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   KokkosFFT::irfft(execution_space(), out1, out2,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                   KokkosFFT::Normalization::backward, /*axis=*/1);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x,
-                    out);  // default: KokkosFFT::Normalization::BACKWARD
+                    out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_b,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_o,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_f,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -2146,19 +2143,19 @@ void test_irfftn_2dfft_2dview() {
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out,
-                    axes);  // default: KokkosFFT::Normalization::BACKWARD
+                    axes);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_b, axes,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_o, axes,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_f, axes,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -2170,22 +2167,22 @@ void test_irfftn_2dfft_2dview() {
 
   // Reuse plans
   KokkosFFT::Impl::Plan irfftn_plan(execution_space(), x, out,
-                                    KokkosFFT::Impl::Direction::Backward, axes);
+                                    KokkosFFT::Direction::backward, axes);
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out, irfftn_plan,
-                    axes);  // default: KokkosFFT::Normalization::BACKWARD
+                    axes);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_b, irfftn_plan, axes,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_o, irfftn_plan, axes,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_f, irfftn_plan, axes,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1));
@@ -2219,27 +2216,27 @@ void test_irfftn_3dfft_3dview() {
   // np.irfftn for 3D array is identical to np.irfft(np.ifft(np.ifft(x, axis=0),
   // axis=1), axis=2)
   KokkosFFT::ifft(execution_space(), x, out1,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/0);
+                  KokkosFFT::Normalization::backward, /*axis=*/0);
   KokkosFFT::ifft(execution_space(), out1, out2,
-                  KokkosFFT::Normalization::BACKWARD, /*axis=*/1);
+                  KokkosFFT::Normalization::backward, /*axis=*/1);
   KokkosFFT::irfft(execution_space(), out2, out3,
-                   KokkosFFT::Normalization::BACKWARD, /*axis=*/2);
+                   KokkosFFT::Normalization::backward, /*axis=*/2);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x,
-                    out);  // default: KokkosFFT::Normalization::BACKWARD
+                    out);  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_b,
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_o,
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_f,
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1 * n2));
@@ -2257,19 +2254,19 @@ void test_irfftn_3dfft_3dview() {
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(
       execution_space(), x, out,
-      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::BACKWARD
+      axes_type{-3, -2, -1});  // default: KokkosFFT::Normalization::backward
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_b, axes_type{-3, -2, -1},
-                    KokkosFFT::Normalization::BACKWARD);
+                    KokkosFFT::Normalization::backward);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_o, axes_type{-3, -2, -1},
-                    KokkosFFT::Normalization::ORTHO);
+                    KokkosFFT::Normalization::ortho);
 
   Kokkos::deep_copy(x, x_ref);
   KokkosFFT::irfftn(execution_space(), x, out_f, axes_type{-3, -2, -1},
-                    KokkosFFT::Normalization::FORWARD);
+                    KokkosFFT::Normalization::forward);
 
   multiply(out_o, 1.0 / sqrt(static_cast<T>(n0 * n1 * n2)));
   multiply(out_f, 1.0 / static_cast<T>(n0 * n1 * n2));