diff --git a/.github/CHANGELOG.md b/.github/CHANGELOG.md
index 0bfeac7b9a..a6f5c5c726 100644
--- a/.github/CHANGELOG.md
+++ b/.github/CHANGELOG.md
@@ -15,6 +15,9 @@
 
 ### Improvements
 
+* Lightning-Kokkos' functors are rewritten as functions wrapping around generic gate and generator functors templated over a coefficient interaction function. This reduces boilerplate while clarifying how the various kernels differ from one another.
+  [(#640)](https://github.com/PennyLaneAI/pennylane-lightning/pull/640)
+  
 * Update C++ and Python GitHub actions names to include the matrix info.
   [(#717)](https://github.com/PennyLaneAI/pennylane-lightning/pull/717)
 
diff --git a/pennylane_lightning/core/_version.py b/pennylane_lightning/core/_version.py
index b98eea33f0..511db7ada4 100644
--- a/pennylane_lightning/core/_version.py
+++ b/pennylane_lightning/core/_version.py
@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.37.0-dev11"
+__version__ = "0.37.0-dev12"
diff --git a/pennylane_lightning/core/src/gates/Gates.hpp b/pennylane_lightning/core/src/gates/Gates.hpp
index 695fe34b0a..32728deca9 100644
--- a/pennylane_lightning/core/src/gates/Gates.hpp
+++ b/pennylane_lightning/core/src/gates/Gates.hpp
@@ -1,37 +1,36 @@
 // Copyright 2018-2023 Xanadu Quantum Technologies Inc.
-
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
-
 //     http://www.apache.org/licenses/LICENSE-2.0
-
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
 #pragma once
-
 #include <cmath>
 #include <complex>
 #include <vector>
 
+#include "GateOperation.hpp"
 #include "Util.hpp"
 
 /// @cond DEV
 namespace {
 using namespace Pennylane::Util;
+using namespace Pennylane::Gates;
 } // namespace
 /// @endcond
 
 namespace Pennylane::Gates {
+
 /**
  * @brief Create a matrix representation of the PauliX gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of PauliX data.
  */
@@ -45,7 +44,8 @@ static constexpr auto getIdentity() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the PauliX gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of PauliX data.
  */
@@ -59,7 +59,8 @@ static constexpr auto getPauliX() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the PauliY gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of PauliY data.
  */
@@ -73,7 +74,8 @@ static constexpr auto getPauliY() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the PauliZ gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of PauliZ data.
  */
@@ -87,7 +89,8 @@ static constexpr auto getPauliZ() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Hadamard gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of Hadamard data.
  */
@@ -100,35 +103,41 @@ static constexpr auto getHadamard() -> std::vector<ComplexT<T>> {
 /**
  * @brief Create a matrix representation of the S gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of S gate data.
  */
 template <template <typename...> class ComplexT, typename T>
-static constexpr auto getS() -> std::vector<ComplexT<T>> {
+static constexpr auto getS(const bool inverse = false)
+    -> std::vector<ComplexT<T>> {
     return {ONE<ComplexT, T>(), ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
-            IMAG<ComplexT, T>()};
+            (inverse) ? -IMAG<ComplexT, T>() : IMAG<ComplexT, T>()};
 }
 
 /**
  * @brief Create a matrix representation of the T gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of T gate data.
  */
 template <template <typename...> class ComplexT, typename T>
-static constexpr auto getT() -> std::vector<ComplexT<T>> {
+static constexpr auto getT(const bool inverse = false)
+    -> std::vector<ComplexT<T>> {
     return {ONE<ComplexT, T>(), ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
-            ConstMult(INVSQRT2<ComplexT, T>(),
-                      ConstSum(ONE<ComplexT, T>(), IMAG<ComplexT, T>()))};
+            INVSQRT2<ComplexT, T>() *
+                (ONE<ComplexT, T>() +
+                 ((inverse) ? -IMAG<ComplexT, T>() : IMAG<ComplexT, T>()))};
 }
 
 /**
  * @brief Create a matrix representation of the CNOT gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of CNOT gate data.
  */
@@ -146,7 +155,8 @@ static constexpr auto getCNOT() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the SWAP gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of SWAP gate data.
  */
@@ -164,7 +174,8 @@ static constexpr auto getSWAP() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the CY gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of SWAP gate data.
  */
@@ -182,7 +193,8 @@ static constexpr auto getCY() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the CZ gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of SWAP gate data.
  */
@@ -200,7 +212,8 @@ static constexpr auto getCZ() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the CSWAP gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of CSWAP gate data.
  */
@@ -234,7 +247,8 @@ static constexpr auto getCSWAP() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Toffoli gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>> Return constant expression
  * of Toffoli gate data.
  */
@@ -268,7 +282,8 @@ static constexpr auto getToffoli() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Phase-shift gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return Phase-shift gate
@@ -286,7 +301,8 @@ static auto getPhaseShift(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the RX gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RX gate data.
@@ -302,7 +318,8 @@ static auto getRX(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the RY gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RY gate data.
@@ -318,7 +335,8 @@ static auto getRY(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the RZ gate data in row-major
  * format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RZ gate data.
@@ -342,7 +360,8 @@ e^{-i(\phi+\omega)/2}\cos(\theta/2) & -e^{i(\phi-\omega)/2}\sin(\theta/2) \\
 e^{-i(\phi-\omega)/2}\sin(\theta/2) & e^{i(\phi+\omega)/2}\cos(\theta/2)
 \end{bmatrix}.\end{split}\f$
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param phi \f$\phi\f$ shift angle.
  * @param theta \f$\theta\f$ shift angle.
@@ -355,7 +374,6 @@ static auto getRot(U phi, U theta, U omega) -> std::vector<ComplexT<T>> {
     const T s = std::sin(theta / 2);
     const U p{phi + omega};
     const U m{phi - omega};
-
     return {ComplexT<T>{std::cos(p / 2) * c, -std::sin(p / 2) * c},
             ComplexT<T>{-std::cos(m / 2) * s, -std::sin(m / 2) * s},
             ComplexT<T>{std::cos(m / 2) * s, -std::sin(m / 2) * s},
@@ -366,14 +384,15 @@ static auto getRot(U phi, U theta, U omega) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the controlled RX gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RX gate data.
  */
 template <template <typename...> class ComplexT, typename T>
 static auto getCRX(T angle) -> std::vector<ComplexT<T>> {
-    const auto rx{getRX<ComplexT<T>>(angle)};
+    const auto rx{getRX<ComplexT, T>(angle)};
     return {ONE<ComplexT, T>(),
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
@@ -396,14 +415,15 @@ static auto getCRX(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the controlled RY gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RY gate data.
  */
 template <template <typename...> class ComplexT, typename T>
 static auto getCRY(T angle) -> std::vector<ComplexT<T>> {
-    const auto ry{getRY<ComplexT<T>>(angle)};
+    const auto ry{getRY<ComplexT, T>(angle)};
     return {ONE<ComplexT, T>(),
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
@@ -426,7 +446,8 @@ static auto getCRY(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the controlled RZ gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return RZ gate data.
@@ -449,6 +470,7 @@ static auto getCRZ(T angle) -> std::vector<ComplexT<T>> {
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
+            ZERO<ComplexT, T>(),
             second};
 }
 
@@ -460,7 +482,7 @@ row-major format.
  */
 template <template <typename...> class ComplexT, typename T>
 static auto getCRot(T phi, T theta, T omega) -> std::vector<ComplexT<T>> {
-    const auto rot{std::move(getRot<ComplexT<T>>(phi, theta, omega))};
+    const auto rot{std::move(getRot<ComplexT, T>(phi, theta, omega))};
     return {ONE<ComplexT, T>(),
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
@@ -501,7 +523,8 @@ static auto getControlledPhaseShift(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the single excitation rotation
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return single excitation rotation
@@ -537,7 +560,8 @@ static auto getSingleExcitation(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the SingleExcitation
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -564,7 +588,8 @@ static constexpr auto getGeneratorSingleExcitation()
  * with negative phase-shift outside the rotation subspace gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return single excitation rotation
@@ -573,7 +598,7 @@ static constexpr auto getGeneratorSingleExcitation()
 template <template <typename...> class ComplexT, typename T>
 static auto getSingleExcitationMinus(T angle) -> std::vector<ComplexT<T>> {
     const T p2 = angle / 2;
-    const ComplexT<T> e = std::exp(ComplexT<T>(0, -p2));
+    const ComplexT<T> e = exp(ComplexT<T>(0, -p2));
     const ComplexT<T> c{std::cos(p2), 0};
     const ComplexT<T> s{std::sin(p2), 0};
     return {e,
@@ -598,7 +623,8 @@ static auto getSingleExcitationMinus(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the SingleExcitation Minus
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -625,7 +651,8 @@ static constexpr auto getGeneratorSingleExcitationMinus()
  * with positive phase-shift outside the rotation subspace gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return single excitation rotation
@@ -634,7 +661,7 @@ static constexpr auto getGeneratorSingleExcitationMinus()
 template <template <typename...> class ComplexT, typename T>
 static auto getSingleExcitationPlus(T angle) -> std::vector<ComplexT<T>> {
     const T p2 = angle / 2;
-    const ComplexT<T> e = std::exp(ComplexT<T>(0, p2));
+    const ComplexT<T> e = exp(ComplexT<T>(0, p2));
     const ComplexT<T> c{std::cos(p2), 0};
     const ComplexT<T> s{std::sin(p2), 0};
     return {e,
@@ -659,7 +686,8 @@ static auto getSingleExcitationPlus(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the SingleExcitation Plus
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -685,7 +713,8 @@ static constexpr auto getGeneratorSingleExcitationPlus()
  * @brief Create a matrix representation of the double excitation rotation
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return double excitation rotation
@@ -722,7 +751,8 @@ static auto getDoubleExcitation(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the DoubleExcitation
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -740,7 +770,8 @@ static constexpr auto getGeneratorDoubleExcitation()
  * with negative phase-shift outside the rotation subspace gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return double excitation rotation
@@ -749,7 +780,7 @@ static constexpr auto getGeneratorDoubleExcitation()
 template <template <typename...> class ComplexT, typename T>
 static auto getDoubleExcitationMinus(T angle) -> std::vector<ComplexT<T>> {
     const T p2 = angle / 2;
-    const ComplexT<T> e = std::exp(ComplexT<T>(0, -p2));
+    const ComplexT<T> e = exp(ComplexT<T>(0, -p2));
     const ComplexT<T> c{std::cos(p2), 0};
     const ComplexT<T> s{std::sin(p2), 0};
     std::vector<ComplexT<T>> mat(256, ZERO<ComplexT, T>());
@@ -778,7 +809,8 @@ static auto getDoubleExcitationMinus(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the DoubleExcitation Minus
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -810,7 +842,8 @@ static constexpr auto getGeneratorDoubleExcitationMinus()
  * with positive phase-shift outside the rotation subspace gate data in
  * row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return double excitation rotation
@@ -819,7 +852,7 @@ static constexpr auto getGeneratorDoubleExcitationMinus()
 template <template <typename...> class ComplexT, typename T>
 static auto getDoubleExcitationPlus(T angle) -> std::vector<ComplexT<T>> {
     const T p2 = angle / 2;
-    const ComplexT<T> e = std::exp(ComplexT<T>(0, p2));
+    const ComplexT<T> e = exp(ComplexT<T>(0, p2));
     const ComplexT<T> c{std::cos(p2), 0};
     const ComplexT<T> s{std::sin(p2), 0};
     std::vector<ComplexT<T>> mat(256, ZERO<ComplexT, T>());
@@ -848,7 +881,8 @@ static auto getDoubleExcitationPlus(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the DoubleExcitation Plus
  * generator data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -879,7 +913,8 @@ static constexpr auto getGeneratorDoubleExcitationPlus()
  * @brief Create a matrix representation of the Ising XX coupling
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return Ising XX coupling
@@ -912,7 +947,54 @@ static auto getIsingXX(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising XX generator
  * data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
+ * @tparam T Required precision of parameter (`float` or `double`).
+ * @return constexpr std::array<CFP_t>
+ */
+template <template <typename...> class ComplexT, typename T>
+static constexpr auto getGeneratorPhaseShift() -> std::vector<ComplexT<T>> {
+    return {
+        ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(),
+        ONE<ComplexT, T>(),
+    };
+}
+
+/**
+ * @brief Create a matrix representation of the Ising XX generator
+ * data in row-major format.
+ *
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
+ * @tparam T Required precision of parameter (`float` or `double`).
+ * @return constexpr std::array<CFP_t>
+ */
+template <template <typename...> class ComplexT, typename T>
+static constexpr auto getGeneratorControlledPhaseShift()
+    -> std::vector<ComplexT<T>> {
+    return {
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+
+        ZERO<ComplexT, T>(), ZERO<ComplexT, T>(),
+        ZERO<ComplexT, T>(), ONE<ComplexT, T>(),
+    };
+}
+
+/**
+ * @brief Create a matrix representation of the Ising XX generator
+ * data in row-major format.
+ *
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::array<CFP_t>
  */
@@ -937,7 +1019,8 @@ static constexpr auto getGeneratorIsingXX() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising XY coupling
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return Ising XY coupling
@@ -973,7 +1056,8 @@ static auto getIsingXY(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising XY generator
  * data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::array<CFP_t>
  */
@@ -998,7 +1082,8 @@ static constexpr auto getGeneratorIsingXY() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising YY coupling
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return Ising YY coupling
@@ -1032,7 +1117,8 @@ static auto getIsingYY(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising YY generator
  * data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::array<CFP_t>
  */
@@ -1057,7 +1143,8 @@ static constexpr auto getGeneratorIsingYY() -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising ZZ coupling
  * gate data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @param angle Phase shift angle.
  * @return std::vector<ComplexT<T>> Return Ising ZZ coupling
@@ -1066,8 +1153,8 @@ static constexpr auto getGeneratorIsingYY() -> std::vector<ComplexT<T>> {
 template <template <typename...> class ComplexT, typename T>
 static auto getIsingZZ(T angle) -> std::vector<ComplexT<T>> {
     const T p2 = angle / 2;
-    const ComplexT<T> neg_e = std::exp(ComplexT<T>(0, -p2));
-    const ComplexT<T> pos_e = std::exp(ComplexT<T>(0, p2));
+    const ComplexT<T> neg_e = exp(ComplexT<T>(0, -p2));
+    const ComplexT<T> pos_e = exp(ComplexT<T>(0, p2));
     return {neg_e,
             ZERO<ComplexT, T>(),
             ZERO<ComplexT, T>(),
@@ -1090,7 +1177,8 @@ static auto getIsingZZ(T angle) -> std::vector<ComplexT<T>> {
  * @brief Create a matrix representation of the Ising ZZ generator
  * data in row-major format.
  *
- * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @tparam ComplexT Complex class.
+ * @tparam T Required precision of gate (`float` or `double`).
  * @tparam T Required precision of parameter (`float` or `double`).
  * @return constexpr std::vector<ComplexT<T>>
  */
@@ -1111,4 +1199,136 @@ static constexpr auto getGeneratorIsingZZ() -> std::vector<ComplexT<T>> {
     };
 }
 
+template <template <typename...> class ComplexT, typename T>
+std::vector<ComplexT<T>> getMatrix(const GateOperation gate_op,
+                                   const std::vector<T> &params,
+                                   const bool inverse = false) {
+    switch (gate_op) {
+    case GateOperation::Identity:
+        return getIdentity<ComplexT, T>();
+    case GateOperation::PauliX:
+        return getPauliX<ComplexT, T>();
+    case GateOperation::PauliY:
+        return getPauliY<ComplexT, T>();
+    case GateOperation::PauliZ:
+        return getPauliZ<ComplexT, T>();
+    case GateOperation::Hadamard:
+        return getHadamard<ComplexT, T>();
+    case GateOperation::S:
+        return getS<ComplexT, T>(inverse);
+    case GateOperation::T:
+        return getT<ComplexT, T>(inverse);
+    case GateOperation::RX:
+        return getRX<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::RY:
+        return getRY<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::RZ:
+        return getRZ<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::PhaseShift:
+        return getPhaseShift<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::Rot:
+        return (inverse)
+                   ? getRot<ComplexT, T>(-params[2], -params[1], -params[0])
+                   : getRot<ComplexT, T>(params[0], params[1], params[2]);
+    case GateOperation::CNOT:
+        return getCNOT<ComplexT, T>();
+    case GateOperation::CY:
+        return getCY<ComplexT, T>();
+    case GateOperation::CZ:
+        return getCZ<ComplexT, T>();
+    case GateOperation::SWAP:
+        return getSWAP<ComplexT, T>();
+    case GateOperation::ControlledPhaseShift:
+        return getControlledPhaseShift<ComplexT, T>((inverse) ? -params[0]
+                                                              : params[0]);
+    case GateOperation::CRX:
+        return getCRX<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::CRY:
+        return getCRY<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::CRZ:
+        return getCRZ<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::CRot:
+        return (inverse)
+                   ? getCRot<ComplexT, T>(-params[2], -params[1], -params[0])
+                   : getCRot<ComplexT, T>(params[0], params[1], params[2]);
+    case GateOperation::IsingXX:
+        return getIsingXX<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::IsingXY:
+        return getIsingXY<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::IsingYY:
+        return getIsingYY<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::IsingZZ:
+        return getIsingZZ<ComplexT, T>((inverse) ? -params[0] : params[0]);
+    case GateOperation::SingleExcitation:
+        return getSingleExcitation<ComplexT, T>((inverse) ? -params[0]
+                                                          : params[0]);
+    case GateOperation::SingleExcitationMinus:
+        return getSingleExcitationMinus<ComplexT, T>((inverse) ? -params[0]
+                                                               : params[0]);
+    case GateOperation::SingleExcitationPlus:
+        return getSingleExcitationPlus<ComplexT, T>((inverse) ? -params[0]
+                                                              : params[0]);
+    case GateOperation::DoubleExcitation:
+        return getDoubleExcitation<ComplexT, T>((inverse) ? -params[0]
+                                                          : params[0]);
+    case GateOperation::DoubleExcitationMinus:
+        return getDoubleExcitationMinus<ComplexT, T>((inverse) ? -params[0]
+                                                               : params[0]);
+    case GateOperation::DoubleExcitationPlus:
+        return getDoubleExcitationPlus<ComplexT, T>((inverse) ? -params[0]
+                                                              : params[0]);
+    case GateOperation::CSWAP:
+        return getCSWAP<ComplexT, T>();
+    case GateOperation::Toffoli:
+        return getToffoli<ComplexT, T>();
+    default:
+        PL_ABORT("This GateOperation does not have a corresponding matrix.");
+    }
+}
+
+template <template <typename...> class ComplexT, typename T>
+std::vector<ComplexT<T>>
+getGeneratorMatrix(const GeneratorOperation generator_op) {
+    switch (generator_op) {
+    case GeneratorOperation::RX:
+        return getPauliX<ComplexT, T>();
+    case GeneratorOperation::RY:
+        return getPauliY<ComplexT, T>();
+    case GeneratorOperation::RZ:
+        return getPauliZ<ComplexT, T>();
+    case GeneratorOperation::PhaseShift:
+        return getGeneratorPhaseShift<ComplexT, T>();
+    case GeneratorOperation::ControlledPhaseShift:
+        return getGeneratorControlledPhaseShift<ComplexT, T>();
+    case GeneratorOperation::CRX:
+        return getCNOT<ComplexT, T>();
+    case GeneratorOperation::CRY:
+        return getCY<ComplexT, T>();
+    case GeneratorOperation::CRZ:
+        return getCZ<ComplexT, T>();
+    case GeneratorOperation::IsingXX:
+        return getGeneratorIsingXX<ComplexT, T>();
+    case GeneratorOperation::IsingXY:
+        return getGeneratorIsingXY<ComplexT, T>();
+    case GeneratorOperation::IsingYY:
+        return getGeneratorIsingYY<ComplexT, T>();
+    case GeneratorOperation::IsingZZ:
+        return getGeneratorIsingZZ<ComplexT, T>();
+    case GeneratorOperation::SingleExcitation:
+        return getGeneratorSingleExcitation<ComplexT, T>();
+    case GeneratorOperation::SingleExcitationMinus:
+        return getGeneratorSingleExcitationMinus<ComplexT, T>();
+    case GeneratorOperation::SingleExcitationPlus:
+        return getGeneratorSingleExcitationPlus<ComplexT, T>();
+    case GeneratorOperation::DoubleExcitation:
+        return getGeneratorDoubleExcitation<ComplexT, T>();
+    case GeneratorOperation::DoubleExcitationMinus:
+        return getGeneratorDoubleExcitationMinus<ComplexT, T>();
+    case GeneratorOperation::DoubleExcitationPlus:
+        return getGeneratorDoubleExcitationPlus<ComplexT, T>();
+    default:
+        PL_ABORT("This GateOperation does not have a corresponding matrix.");
+    }
+}
+
 } // namespace Pennylane::Gates
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/StateVectorKokkos.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/StateVectorKokkos.hpp
index 5ef82d138a..0e073eb367 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/StateVectorKokkos.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/StateVectorKokkos.hpp
@@ -74,12 +74,12 @@ class StateVectorKokkos final
     using HostExecSpace = Kokkos::DefaultHostExecutionSpace;
     using KokkosExecSpace = Kokkos::DefaultExecutionSpace;
     using KokkosVector = Kokkos::View<ComplexT *>;
-    using KokkosSizeTVector = Kokkos::View<size_t *>;
+    using KokkosSizeTVector = Kokkos::View<std::size_t *>;
     using UnmanagedComplexHostView =
         Kokkos::View<ComplexT *, Kokkos::HostSpace,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
     using UnmanagedSizeTHostView =
-        Kokkos::View<size_t *, Kokkos::HostSpace,
+        Kokkos::View<std::size_t *, Kokkos::HostSpace,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
     using UnmanagedConstComplexHostView =
         Kokkos::View<const ComplexT *, Kokkos::HostSpace,
@@ -94,13 +94,13 @@ class StateVectorKokkos final
         Kokkos::View<ComplexT *, KokkosExecSpace::scratch_memory_space,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
     using ScratchViewSizeT =
-        Kokkos::View<size_t *, KokkosExecSpace::scratch_memory_space,
+        Kokkos::View<std::size_t *, KokkosExecSpace::scratch_memory_space,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
     using TeamPolicy = Kokkos::TeamPolicy<>;
     using MemoryStorageT = Pennylane::Util::MemoryStorageLocation::Undefined;
 
     StateVectorKokkos() = delete;
-    StateVectorKokkos(size_t num_qubits,
+    StateVectorKokkos(std::size_t num_qubits,
                       const Kokkos::InitializationSettings &kokkos_args = {})
         : BaseType{num_qubits} {
         num_qubits_ = num_qubits;
@@ -269,9 +269,13 @@ class StateVectorKokkos final
                 applyControlledGlobalPhase<false>(gate_matrix);
             }
         } else if (array_contains(gate_names, std::string_view{opName})) {
-            applyNamedOperation(opName, wires, inverse, params);
+            const std::size_t num_qubits = this->getNumQubits();
+            const GateOperation gateop =
+                reverse_lookup(gate_names, std::string_view{opName});
+            applyNamedOperation<KokkosExecSpace>(gateop, *data_, num_qubits,
+                                                 wires, inverse, params);
         } else {
-            PL_ABORT_IF(gate_matrix.size() == 0,
+            PL_ABORT_IF(gate_matrix.empty(),
                         std::string("Operation does not exist for ") + opName +
                             std::string(" and no matrix provided."));
             KokkosVector matrix("gate_matrix", gate_matrix.size());
@@ -328,7 +332,7 @@ class StateVectorKokkos final
      * @param wires Wires to apply gate to.
      * @param inverse Indicates whether to use adjoint of gate.
      */
-    void applyMultiQubitOp(const KokkosVector &matrix,
+    void applyMultiQubitOp(const KokkosVector matrix,
                            const std::vector<std::size_t> &wires,
                            bool inverse = false) {
         auto &&num_qubits = this->getNumQubits();
@@ -450,125 +454,6 @@ class StateVectorKokkos final
         applyMatrix(matrix.data(), wires, inverse);
     }
 
-    void applyNamedOperation(const std::string &opName,
-                             const std::vector<std::size_t> &wires,
-                             bool inverse = false,
-                             const std::vector<fp_t> &params = {}) {
-        switch (reverse_lookup(gate_names, std::string_view{opName})) {
-        case GateOperation::PauliX:
-            applyGateFunctor<pauliXFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::PauliY:
-            applyGateFunctor<pauliYFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::PauliZ:
-            applyGateFunctor<pauliZFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::Hadamard:
-            applyGateFunctor<hadamardFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::S:
-            applyGateFunctor<sFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::T:
-            applyGateFunctor<tFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::RX:
-            applyGateFunctor<rxFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::RY:
-            applyGateFunctor<ryFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::RZ:
-            applyGateFunctor<rzFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::PhaseShift:
-            applyGateFunctor<phaseShiftFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::Rot:
-            applyGateFunctor<rotFunctor, 1>(wires, inverse, params);
-            return;
-        case GateOperation::CY:
-            applyGateFunctor<cyFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::CZ:
-            applyGateFunctor<czFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::CNOT:
-            applyGateFunctor<cnotFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::SWAP:
-            applyGateFunctor<swapFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::ControlledPhaseShift:
-            applyGateFunctor<controlledPhaseShiftFunctor, 2>(wires, inverse,
-                                                             params);
-            return;
-        case GateOperation::CRX:
-            applyGateFunctor<crxFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::CRY:
-            applyGateFunctor<cryFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::CRZ:
-            applyGateFunctor<crzFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::CRot:
-            applyGateFunctor<cRotFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::IsingXX:
-            applyGateFunctor<isingXXFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::IsingXY:
-            applyGateFunctor<isingXYFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::IsingYY:
-            applyGateFunctor<isingYYFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::IsingZZ:
-            applyGateFunctor<isingZZFunctor, 2>(wires, inverse, params);
-            return;
-        case GateOperation::SingleExcitation:
-            applyGateFunctor<singleExcitationFunctor, 2>(wires, inverse,
-                                                         params);
-            return;
-        case GateOperation::SingleExcitationMinus:
-            applyGateFunctor<singleExcitationMinusFunctor, 2>(wires, inverse,
-                                                              params);
-            return;
-        case GateOperation::SingleExcitationPlus:
-            applyGateFunctor<singleExcitationPlusFunctor, 2>(wires, inverse,
-                                                             params);
-            return;
-        case GateOperation::DoubleExcitation:
-            applyGateFunctor<doubleExcitationFunctor, 4>(wires, inverse,
-                                                         params);
-            return;
-        case GateOperation::DoubleExcitationMinus:
-            applyGateFunctor<doubleExcitationMinusFunctor, 4>(wires, inverse,
-                                                              params);
-            return;
-        case GateOperation::DoubleExcitationPlus:
-            applyGateFunctor<doubleExcitationPlusFunctor, 4>(wires, inverse,
-                                                             params);
-            return;
-        case GateOperation::MultiRZ:
-            applyMultiRZ(wires, inverse, params);
-            return;
-        case GateOperation::GlobalPhase:
-            applyGlobalPhase(wires, inverse, params);
-            return;
-        case GateOperation::CSWAP:
-            applyGateFunctor<cSWAPFunctor, 3>(wires, inverse, params);
-            return;
-        case GateOperation::Toffoli:
-            applyGateFunctor<toffoliFunctor, 3>(wires, inverse, params);
-            return;
-        default:
-            PL_ABORT(std::string("Operation does not exist for ") + opName);
-        }
-    }
-
     /**
      * @brief Apply a single generator to the state vector using the given
      * kernel.
@@ -582,184 +467,11 @@ class StateVectorKokkos final
                         const std::vector<std::size_t> &wires,
                         bool inverse = false,
                         const std::vector<fp_t> &params = {}) -> fp_t {
-        switch (reverse_lookup(generator_names, std::string_view{opName})) {
-        case GeneratorOperation::RX:
-            applyGateFunctor<pauliXFunctor, 1>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::RY:
-            applyGateFunctor<pauliYFunctor, 1>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::RZ:
-            applyGateFunctor<pauliZFunctor, 1>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::PhaseShift:
-            applyGateFunctor<generatorPhaseShiftFunctor, 1>(wires, inverse,
-                                                            params);
-            return static_cast<fp_t>(1.0);
-        case GeneratorOperation::IsingXX:
-            applyGateFunctor<generatorIsingXXFunctor, 2>(wires, inverse,
-                                                         params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::IsingXY:
-            applyGateFunctor<generatorIsingXYFunctor, 2>(wires, inverse,
-                                                         params);
-            return static_cast<fp_t>(0.5);
-        case GeneratorOperation::IsingYY:
-            applyGateFunctor<generatorIsingYYFunctor, 2>(wires, inverse,
-                                                         params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::IsingZZ:
-            applyGateFunctor<generatorIsingZZFunctor, 2>(wires, inverse,
-                                                         params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::SingleExcitation:
-            applyGateFunctor<generatorSingleExcitationFunctor, 2>(
-                wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::SingleExcitationMinus:
-            applyGateFunctor<generatorSingleExcitationMinusFunctor, 2>(
-                wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::SingleExcitationPlus:
-            applyGateFunctor<generatorSingleExcitationPlusFunctor, 2>(
-                wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::DoubleExcitation:
-            applyGateFunctor<generatorDoubleExcitationFunctor, 4>(
-                wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::DoubleExcitationMinus:
-            applyGateFunctor<generatorDoubleExcitationMinusFunctor, 4>(
-                wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::DoubleExcitationPlus:
-            applyGateFunctor<generatorDoubleExcitationPlusFunctor, 4>(
-                wires, inverse, params);
-            return static_cast<fp_t>(0.5);
-        case GeneratorOperation::ControlledPhaseShift:
-            applyGateFunctor<generatorControlledPhaseShiftFunctor, 2>(
-                wires, inverse, params);
-            return static_cast<fp_t>(1);
-        case GeneratorOperation::CRX:
-            applyGateFunctor<generatorCRXFunctor, 2>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::CRY:
-            applyGateFunctor<generatorCRYFunctor, 2>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::CRZ:
-            applyGateFunctor<generatorCRZFunctor, 2>(wires, inverse, params);
-            return -static_cast<fp_t>(0.5);
-        case GeneratorOperation::MultiRZ:
-            return applyGeneratorMultiRZ(wires, inverse, params);
-        case GeneratorOperation::GlobalPhase:
-            return static_cast<PrecisionT>(-1.0);
-        /// LCOV_EXCL_START
-        default:
-            PL_ABORT(std::string("Generator does not exist for ") + opName);
-            /// LCOV_EXCL_STOP
-        }
-    }
-
-    /**
-     * @brief Templated method that applies special n-qubit gates.
-     *
-     * @tparam functor_t Gate functor class for Kokkos dispatcher.
-     * @tparam nqubits Number of qubits.
-     * @param wires Wires to apply gate to.
-     * @param inverse Indicates whether to use adjoint of gate.
-     * @param params parameters for this gate
-     */
-    template <template <class, bool> class functor_t, int nqubits>
-    void applyGateFunctor(const std::vector<std::size_t> &wires,
-                          bool inverse = false,
-                          const std::vector<fp_t> &params = {}) {
-        auto &&num_qubits = this->getNumQubits();
-        PL_ASSERT(wires.size() == nqubits);
-        PL_ASSERT(wires.size() <= num_qubits);
-        if (!inverse) {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(
-                    0, exp2(num_qubits - nqubits)),
-                functor_t<fp_t, false>(*data_, num_qubits, wires, params));
-        } else {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(
-                    0, exp2(num_qubits - nqubits)),
-                functor_t<fp_t, true>(*data_, num_qubits, wires, params));
-        }
-    }
-
-    /**
-     * @brief Apply a MultiRZ operator to the state vector using a matrix
-     *
-     * @param wires Wires to apply gate to.
-     * @param inverse Indicates whether to use adjoint of gate.
-     * @param params parameters for this gate
-     */
-    void applyMultiRZ(const std::vector<std::size_t> &wires,
-                      bool inverse = false,
-                      const std::vector<fp_t> &params = {}) {
-        auto &&num_qubits = this->getNumQubits();
-
-        if (!inverse) {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                multiRZFunctor<fp_t, false>(*data_, num_qubits, wires, params));
-        } else {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                multiRZFunctor<fp_t, true>(*data_, num_qubits, wires, params));
-        }
-    }
-
-    /**
-     * @brief Apply a GlobalPhase operator to the state vector using a matrix
-     *
-     * @param wires Wires to apply gate to.
-     * @param inverse Indicates whether to use adjoint of gate.
-     * @param params parameters for this gate
-     */
-    void applyGlobalPhase(const std::vector<std::size_t> &wires,
-                          bool inverse = false,
-                          const std::vector<fp_t> &params = {}) {
-        auto &&num_qubits = this->getNumQubits();
-
-        if (!inverse) {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                globalPhaseFunctor<fp_t, false>(*data_, num_qubits, wires,
-                                                params));
-        } else {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                globalPhaseFunctor<fp_t, true>(*data_, num_qubits, wires,
-                                               params));
-        }
-    }
-
-    /**
-     * @brief Apply a MultiRZ generator to the state vector using a matrix
-     *
-     * @param wires Wires to apply gate to.
-     * @param inverse Indicates whether to use adjoint of gate.
-     * @param params parameters for this gate
-     */
-    auto applyGeneratorMultiRZ(
-        const std::vector<std::size_t> &wires, bool inverse = false,
-        [[maybe_unused]] const std::vector<fp_t> &params = {}) -> fp_t {
-        auto &&num_qubits = this->getNumQubits();
-
-        if (inverse == false) {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                generatorMultiRZFunctor<fp_t, false>(*data_, num_qubits,
-                                                     wires));
-        } else {
-            Kokkos::parallel_for(
-                Kokkos::RangePolicy<KokkosExecSpace>(0, exp2(num_qubits)),
-                generatorMultiRZFunctor<fp_t, true>(*data_, num_qubits, wires));
-        }
-        return -static_cast<fp_t>(0.5);
+        const std::size_t num_qubits = this->getNumQubits();
+        const GeneratorOperation generator_op =
+            reverse_lookup(generator_names, std::string_view{opName});
+        return applyNamedGenerator<KokkosExecSpace>(
+            generator_op, *data_, num_qubits, wires, inverse, params);
     }
 
     /**
@@ -814,7 +526,7 @@ class StateVectorKokkos final
      *
      * @param other Kokkos View
      */
-    void updateData(const KokkosVector &other) {
+    void updateData(const KokkosVector other) {
         Kokkos::deep_copy(*data_, other);
     }
 
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/AdjointJacobianKokkos.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/AdjointJacobianKokkos.hpp
index 834d693ce1..e48d32add5 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/AdjointJacobianKokkos.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/AdjointJacobianKokkos.hpp
@@ -152,7 +152,7 @@ class AdjointJacobian final
                             ops.getOpsWires()[op_idx],
                             !ops.getOpsInverses()[op_idx]) *
                         (ops.getOpsInverses()[op_idx] ? -1 : 1);
-                    for (size_t obs_idx = 0; obs_idx < num_observables;
+                    for (std::size_t obs_idx = 0; obs_idx < num_observables;
                          obs_idx++) {
                         const std::size_t idx =
                             trainableParamNumber + obs_idx * tp_size;
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/tests/Test_AdjointJacobianKokkos.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/tests/Test_AdjointJacobianKokkos.cpp
index 71d896ff02..fe557b72bf 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/tests/Test_AdjointJacobianKokkos.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/tests/Test_AdjointJacobianKokkos.cpp
@@ -68,11 +68,11 @@ TEMPLATE_PRODUCT_TEST_CASE(
 
     std::uniform_real_distribution<PrecisionT> dist(-1.0, 1.0);
 
-    for (size_t k = 0; k < n_terms; k++) {
+    for (std::size_t k = 0; k < n_terms; k++) {
         auto term_pauli = randomIntVector(re, num_qubits, 0, 3);
 
         std::vector<std::shared_ptr<Observable<StateVectorT>>> term_comp;
-        for (size_t i = 0; i < num_qubits; i++) {
+        for (std::size_t i = 0; i < num_qubits; i++) {
             if (term_pauli[i] == 0) {
                 continue;
             }
@@ -86,7 +86,7 @@ TEMPLATE_PRODUCT_TEST_CASE(
         coeffs.emplace_back(dist(re));
         terms.emplace_back(TensorProdObs<StateVectorT>::create(term_comp));
     }
-    std::vector<ComplexT> psi(size_t{1} << num_qubits);
+    std::vector<ComplexT> psi(std::size_t{1} << num_qubits);
     std::normal_distribution<PrecisionT> ndist;
     for (auto &e : psi) {
         e = ndist(re);
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGateFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGateFunctors.hpp
new file mode 100644
index 0000000000..0768e2aaa3
--- /dev/null
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGateFunctors.hpp
@@ -0,0 +1,1189 @@
+// Copyright 2018-2024 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an AS IS BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_StdAlgorithms.hpp>
+
+#include "BitUtil.hpp"
+#include "GateOperation.hpp"
+#include "Gates.hpp"
+
+/// @cond DEV
+namespace {
+using namespace Pennylane::Util;
+using Kokkos::Experimental::swap;
+using Pennylane::Gates::GateOperation;
+} // namespace
+/// @endcond
+
+namespace Pennylane::LightningKokkos::Functors {
+
+template <class PrecisionT, class FuncT> class applyNC1Functor {
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
+    const FuncT core_function;
+    const std::size_t rev_wire;
+    const std::size_t rev_wire_shift;
+    const std::size_t wire_parity;
+    const std::size_t wire_parity_inv;
+
+  public:
+    template <class ExecutionSpace>
+    applyNC1Functor([[maybe_unused]] ExecutionSpace exec,
+                    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                    std::size_t num_qubits,
+                    const std::vector<std::size_t> &wires, FuncT core_function_)
+        : arr(arr_), core_function(core_function_),
+          rev_wire(num_qubits - wires[0] - 1),
+          rev_wire_shift((static_cast<std::size_t>(1U) << rev_wire)),
+          wire_parity(fillTrailingOnes(rev_wire)),
+          wire_parity_inv(fillLeadingOnes(rev_wire + 1)) {
+        Kokkos::parallel_for(
+            Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits - 1)),
+            *this);
+    }
+    KOKKOS_FUNCTION void operator()(const std::size_t k) const {
+        const std::size_t i0 =
+            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
+        const std::size_t i1 = i0 | rev_wire_shift;
+        core_function(arr, i0, i1);
+    }
+};
+
+template <class ExecutionSpace, class PrecisionT>
+void applyPauliX(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            Kokkos::Experimental::swap(arr(i0), arr(i1));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyPauliY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            const auto v0 = arr(i0);
+            const auto v1 = arr(i1);
+            arr(i0) = Kokkos::complex<PrecisionT>{imag(v1), -real(v1)};
+            arr(i1) = Kokkos::complex<PrecisionT>{-imag(v0), real(v0)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyPauliZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i0,
+                      const std::size_t i1) { arr(i1) *= -1.0; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyHadamard(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i0,
+                      const std::size_t i1) {
+            const Kokkos::complex<PrecisionT> v0 = arr(i0);
+            const Kokkos::complex<PrecisionT> v1 = arr(i1);
+            arr(i0) = M_SQRT1_2 * v0 +
+                      M_SQRT1_2 * v1; // NOLINT(readability-magic-numbers)
+            arr(i1) = M_SQRT1_2 * v0 +
+                      -M_SQRT1_2 * v1; // NOLINT(readability-magic-numbers)
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyS(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+            const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+            const bool inverse = false,
+            [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    const Kokkos::complex<PrecisionT> shift =
+        (inverse) ? -IMAG<Kokkos::complex, PrecisionT>()
+                  : IMAG<Kokkos::complex, PrecisionT>();
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i0,
+                      const std::size_t i1) { arr(i1) *= shift; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyT(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+            const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+            const bool inverse = false,
+            [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    const Kokkos::complex<PrecisionT> shift =
+        (inverse) ? conj(exp(Kokkos::complex<PrecisionT>(
+                        0, static_cast<PrecisionT>(M_PI / 4))))
+                  : exp(Kokkos::complex<PrecisionT>(
+                        0, static_cast<PrecisionT>(M_PI / 4)));
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i0,
+                      const std::size_t i1) { arr(i1) *= shift; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyPhaseShift(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                     const std::size_t num_qubits,
+                     const std::vector<std::size_t> &wires,
+                     const bool inverse = false,
+                     const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const Kokkos::complex<PrecisionT> shift =
+        (inverse) ? exp(-Kokkos::complex<PrecisionT>(0, angle))
+                  : exp(Kokkos::complex<PrecisionT>(0, angle));
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i0,
+                      const std::size_t i1) { arr(i1) *= shift; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyRX(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+             const std::size_t num_qubits,
+             const std::vector<std::size_t> &wires, const bool inverse = false,
+             const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT c = cos(angle * static_cast<PrecisionT>(0.5));
+    const PrecisionT s = (inverse) ? sin(angle * static_cast<PrecisionT>(0.5))
+                                   : sin(-angle * static_cast<PrecisionT>(0.5));
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            const auto v0 = arr(i0);
+            const auto v1 = arr(i1);
+            arr(i0) = c * v0 +
+                      Kokkos::complex<PrecisionT>{-imag(v1) * s, real(v1) * s};
+            arr(i1) = Kokkos::complex<PrecisionT>{-imag(v0) * s, real(v0) * s} +
+                      c * v1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyRY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+             const std::size_t num_qubits,
+             const std::vector<std::size_t> &wires, const bool inverse = false,
+             const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT c = cos(angle * static_cast<PrecisionT>(0.5));
+    const PrecisionT s = (inverse) ? -sin(angle * static_cast<PrecisionT>(0.5))
+                                   : sin(angle * static_cast<PrecisionT>(0.5));
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            const auto v0 = arr(i0);
+            const auto v1 = arr(i1);
+            arr(i0) = Kokkos::complex<PrecisionT>{c * real(v0) - s * real(v1),
+                                                  c * imag(v0) - s * imag(v1)};
+            arr(i1) = Kokkos::complex<PrecisionT>{s * real(v0) + c * real(v1),
+                                                  s * imag(v0) + c * imag(v1)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyRZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+             const std::size_t num_qubits,
+             const std::vector<std::size_t> &wires, const bool inverse = false,
+             const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cos_angle = cos(angle * static_cast<PrecisionT>(0.5));
+    const PrecisionT sin_angle = sin(angle * static_cast<PrecisionT>(0.5));
+    const Kokkos::complex<PrecisionT> shift_0{
+        cos_angle, (inverse) ? sin_angle : -sin_angle};
+    const Kokkos::complex<PrecisionT> shift_1 = Kokkos::conj(shift_0);
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            arr(i0) *= shift_0;
+            arr(i1) *= shift_1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyRot(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+              const std::size_t num_qubits,
+              const std::vector<std::size_t> &wires, const bool inverse = false,
+              const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT phi = (inverse) ? -params[2] : params[0];
+    const PrecisionT theta = (inverse) ? -params[1] : params[1];
+    const PrecisionT omega = (inverse) ? -params[0] : params[2];
+    const auto mat = Pennylane::Gates::getRot<Kokkos::complex, PrecisionT>(
+        phi, theta, omega);
+    const Kokkos::complex<PrecisionT> mat_0b00 = mat[0b00];
+    const Kokkos::complex<PrecisionT> mat_0b01 = mat[0b01];
+    const Kokkos::complex<PrecisionT> mat_0b10 = mat[0b10];
+    const Kokkos::complex<PrecisionT> mat_0b11 = mat[0b11];
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0, const std::size_t i1) {
+            const Kokkos::complex<PrecisionT> v0 = arr(i0);
+            const Kokkos::complex<PrecisionT> v1 = arr(i1);
+            arr(i0) = mat_0b00 * v0 + mat_0b01 * v1;
+            arr(i1) = mat_0b10 * v0 + mat_0b11 * v1;
+        });
+}
+
+template <class PrecisionT, class FuncT> class applyNC2Functor {
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
+    const FuncT core_function;
+    const std::size_t rev_wire0;
+    const std::size_t rev_wire1;
+    const std::size_t rev_wire0_shift;
+    const std::size_t rev_wire1_shift;
+    const std::size_t rev_wire_min;
+    const std::size_t rev_wire_max;
+    const std::size_t parity_low;
+    const std::size_t parity_high;
+    const std::size_t parity_middle;
+
+  public:
+    template <class ExecutionSpace>
+    applyNC2Functor([[maybe_unused]] ExecutionSpace exec,
+                    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                    std::size_t num_qubits,
+                    const std::vector<std::size_t> &wires, FuncT core_function_)
+        : arr(arr_), core_function(core_function_),
+          rev_wire0(num_qubits - wires[1] - 1),
+          rev_wire1(num_qubits - wires[0] - 1),
+          rev_wire0_shift(static_cast<std::size_t>(1U) << rev_wire0),
+          rev_wire1_shift(static_cast<std::size_t>(1U) << rev_wire1),
+          rev_wire_min(std::min(rev_wire0, rev_wire1)),
+          rev_wire_max(std::max(rev_wire0, rev_wire1)),
+          parity_low(fillTrailingOnes(rev_wire_min)),
+          parity_high(fillLeadingOnes(rev_wire_max + 1)),
+          parity_middle(fillLeadingOnes(rev_wire_min + 1) &
+                        fillTrailingOnes(rev_wire_max)) {
+        Kokkos::parallel_for(
+            Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits - 2)),
+            *this);
+    }
+    KOKKOS_FUNCTION void operator()(const std::size_t k) const {
+        const std::size_t i00 = ((k << 2U) & parity_high) |
+                                ((k << 1U) & parity_middle) | (k & parity_low);
+        const std::size_t i01 = i00 | rev_wire0_shift;
+        const std::size_t i10 = i00 | rev_wire1_shift;
+        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
+        core_function(arr, i00, i01, i10, i11);
+    }
+};
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCNOT(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+               const std::size_t num_qubits,
+               const std::vector<std::size_t> &wires,
+               [[maybe_unused]] const bool inverse = false,
+               [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            Kokkos::Experimental::swap(arr(i10), arr(i11));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+             const std::size_t num_qubits,
+             const std::vector<std::size_t> &wires,
+             [[maybe_unused]] const bool inverse = false,
+             [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            Kokkos::complex<PrecisionT> v10 = arr(i10);
+            arr(i10) =
+                Kokkos::complex<PrecisionT>{imag(arr(i11)), -real(arr(i11))};
+            arr(i11) = Kokkos::complex<PrecisionT>{-imag(v10), real(v10)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+             const std::size_t num_qubits,
+             const std::vector<std::size_t> &wires,
+             [[maybe_unused]] const bool inverse = false,
+             [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      [[maybe_unused]] const std::size_t i10,
+                      const std::size_t i11) { arr(i11) *= -1; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applySWAP(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+               const std::size_t num_qubits,
+               const std::vector<std::size_t> &wires,
+               [[maybe_unused]] const bool inverse = false,
+               [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyControlledPhaseShift(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                               const std::size_t num_qubits,
+                               const std::vector<std::size_t> &wires,
+                               const bool inverse = false,
+                               const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const Kokkos::complex<PrecisionT> s =
+        (inverse) ? exp(-Kokkos::complex<PrecisionT>(0, angle))
+                  : exp(Kokkos::complex<PrecisionT>(0, angle));
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      [[maybe_unused]] const std::size_t i10,
+                      const std::size_t i11) { arr(i11) *= s; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCRX(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+              const std::size_t num_qubits,
+              const std::vector<std::size_t> &wires, const bool inverse = false,
+              const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT c = std::cos(angle / 2);
+    const PrecisionT js =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            const Kokkos::complex<PrecisionT> v11 = arr(i11);
+            arr(i10) = Kokkos::complex<PrecisionT>{
+                c * real(v10) + js * imag(v11), c * imag(v10) - js * real(v11)};
+            arr(i11) = Kokkos::complex<PrecisionT>{
+                c * real(v11) + js * imag(v10), c * imag(v11) - js * real(v10)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCRY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+              const std::size_t num_qubits,
+              const std::vector<std::size_t> &wires, const bool inverse = false,
+              const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT c = std::cos(angle / 2);
+    const PrecisionT s = (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            const Kokkos::complex<PrecisionT> v11 = arr(i11);
+            arr(i10) = c * v10 - s * v11;
+            arr(i11) = s * v10 + c * v11;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCRZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+              const std::size_t num_qubits,
+              const std::vector<std::size_t> &wires, const bool inverse = false,
+              const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cos_angle = cos(angle * static_cast<PrecisionT>(0.5));
+    const PrecisionT sin_angle = sin(angle * static_cast<PrecisionT>(0.5));
+    const Kokkos::complex<PrecisionT> shift_0{
+        cos_angle, (inverse) ? sin_angle : -sin_angle};
+    const Kokkos::complex<PrecisionT> shift_1 = Kokkos::conj(shift_0);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            arr(i10) *= shift_0;
+            arr(i11) *= shift_1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCRot(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+               const std::size_t num_qubits,
+               const std::vector<std::size_t> &wires,
+               const bool inverse = false,
+               const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT phi = (inverse) ? -params[2] : params[0];
+    const PrecisionT theta = (inverse) ? -params[1] : params[1];
+    const PrecisionT omega = (inverse) ? -params[0] : params[2];
+    const auto mat = Pennylane::Gates::getRot<Kokkos::complex, PrecisionT>(
+        phi, theta, omega);
+    const Kokkos::complex<PrecisionT> mat_0b00 = mat[0b00];
+    const Kokkos::complex<PrecisionT> mat_0b01 = mat[0b01];
+    const Kokkos::complex<PrecisionT> mat_0b10 = mat[0b10];
+    const Kokkos::complex<PrecisionT> mat_0b11 = mat[0b11];
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      [[maybe_unused]] const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v0 = arr(i10);
+            const Kokkos::complex<PrecisionT> v1 = arr(i11);
+            arr(i10) = mat_0b00 * v0 + mat_0b01 * v1;
+            arr(i11) = mat_0b10 * v0 + mat_0b11 * v1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyIsingXX(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  const bool inverse = false,
+                  const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v00 = arr(i00);
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            const Kokkos::complex<PrecisionT> v11 = arr(i11);
+            arr(i00) =
+                Kokkos::complex<PrecisionT>{cr * real(v00) + sj * imag(v11),
+                                            cr * imag(v00) - sj * real(v11)};
+            arr(i01) =
+                Kokkos::complex<PrecisionT>{cr * real(v01) + sj * imag(v10),
+                                            cr * imag(v01) - sj * real(v10)};
+            arr(i10) =
+                Kokkos::complex<PrecisionT>{cr * real(v10) + sj * imag(v01),
+                                            cr * imag(v10) - sj * real(v01)};
+            arr(i11) =
+                Kokkos::complex<PrecisionT>{cr * real(v11) + sj * imag(v00),
+                                            cr * imag(v11) - sj * real(v00)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyIsingXY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  const bool inverse = false,
+                  const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v00 = arr(i00);
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            const Kokkos::complex<PrecisionT> v11 = arr(i11);
+            arr(i00) = Kokkos::complex<PrecisionT>{real(v00), imag(v00)};
+            arr(i01) =
+                Kokkos::complex<PrecisionT>{cr * real(v01) - sj * imag(v10),
+                                            cr * imag(v01) + sj * real(v10)};
+            arr(i10) =
+                Kokkos::complex<PrecisionT>{cr * real(v10) - sj * imag(v01),
+                                            cr * imag(v10) + sj * real(v01)};
+            arr(i11) = Kokkos::complex<PrecisionT>{real(v11), imag(v11)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyIsingYY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  const bool inverse = false,
+                  const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v00 = arr(i00);
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            const Kokkos::complex<PrecisionT> v11 = arr(i11);
+            arr(i00) =
+                Kokkos::complex<PrecisionT>{cr * real(v00) - sj * imag(v11),
+                                            cr * imag(v00) + sj * real(v11)};
+            arr(i01) =
+                Kokkos::complex<PrecisionT>{cr * real(v01) + sj * imag(v10),
+                                            cr * imag(v01) - sj * real(v10)};
+            arr(i10) =
+                Kokkos::complex<PrecisionT>{cr * real(v10) + sj * imag(v01),
+                                            cr * imag(v10) - sj * real(v01)};
+            arr(i11) =
+                Kokkos::complex<PrecisionT>{cr * real(v11) - sj * imag(v00),
+                                            cr * imag(v11) + sj * real(v00)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyIsingZZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  const bool inverse = false,
+                  const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const Kokkos::complex<PrecisionT> shift_0 = Kokkos::complex<PrecisionT>{
+        std::cos(angle / 2),
+        (inverse) ? std::sin(angle / 2) : -std::sin(angle / 2)};
+    const Kokkos::complex<PrecisionT> shift_1 = conj(shift_0);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            arr(i00) *= shift_0;
+            arr(i01) *= shift_1;
+            arr(i10) *= shift_1;
+            arr(i11) *= shift_0;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applySingleExcitation(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                           const std::size_t num_qubits,
+                           const std::vector<std::size_t> &wires,
+                           const bool inverse = false,
+                           const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            arr(i01) = cr * v01 - sj * v10;
+            arr(i10) = sj * v01 + cr * v10;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applySingleExcitationMinus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    const bool inverse = false, const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    const Kokkos::complex<PrecisionT> e =
+        (inverse) ? exp(Kokkos::complex<PrecisionT>(0, angle / 2))
+                  : exp(Kokkos::complex<PrecisionT>(0, -angle / 2));
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            arr(i00) *= e;
+            arr(i01) = cr * v01 - sj * v10;
+            arr(i10) = sj * v01 + cr * v10;
+            arr(i11) *= e;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applySingleExcitationPlus(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                               const std::size_t num_qubits,
+                               const std::vector<std::size_t> &wires,
+                               const bool inverse = false,
+                               const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    const Kokkos::complex<PrecisionT> e =
+        (inverse) ? exp(Kokkos::complex<PrecisionT>(0, -angle / 2))
+                  : exp(Kokkos::complex<PrecisionT>(0, angle / 2));
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            const Kokkos::complex<PrecisionT> v01 = arr(i01);
+            const Kokkos::complex<PrecisionT> v10 = arr(i10);
+            arr(i00) *= e;
+            arr(i01) = cr * v01 - sj * v10;
+            arr(i10) = sj * v01 + cr * v10;
+            arr(i11) *= e;
+        });
+}
+
+template <class PrecisionT, class FuncT> class applyNC3Functor {
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
+    const FuncT core_function;
+    const std::size_t rev_wire0;
+    const std::size_t rev_wire1;
+    const std::size_t rev_wire2;
+    const std::size_t rev_wire0_shift;
+    const std::size_t rev_wire1_shift;
+    const std::size_t rev_wire2_shift;
+    std::size_t parity_low;
+    std::size_t parity_high;
+    std::size_t parity_hmiddle;
+    std::size_t parity_lmiddle;
+
+  public:
+    template <class ExecutionSpace>
+    applyNC3Functor([[maybe_unused]] ExecutionSpace exec,
+                    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                    std::size_t num_qubits,
+                    const std::vector<std::size_t> &wires, FuncT core_function_)
+        : arr(arr_), core_function(core_function_),
+          rev_wire0(num_qubits - wires[2] - 1),
+          rev_wire1(num_qubits - wires[1] - 1),
+          rev_wire2(num_qubits - wires[0] - 1),
+          rev_wire0_shift(static_cast<std::size_t>(1U) << rev_wire0),
+          rev_wire1_shift(static_cast<std::size_t>(1U) << rev_wire1),
+          rev_wire2_shift(static_cast<std::size_t>(1U) << rev_wire2) {
+        std::size_t rev_wire_min = std::min(rev_wire0, rev_wire1);
+        std::size_t rev_wire_max = std::max(rev_wire0, rev_wire1);
+        std::size_t rev_wire_mid{0U};
+        if (rev_wire2 < rev_wire_min) {
+            rev_wire_mid = rev_wire_min;
+            rev_wire_min = rev_wire2;
+        } else if (rev_wire2 > rev_wire_max) {
+            rev_wire_mid = rev_wire_max;
+            rev_wire_max = rev_wire2;
+        } else {
+            rev_wire_mid = rev_wire2;
+        }
+        parity_low = fillTrailingOnes(rev_wire_min);
+        parity_high = fillLeadingOnes(rev_wire_max + 1);
+        parity_lmiddle =
+            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_mid);
+        parity_hmiddle =
+            fillLeadingOnes(rev_wire_mid + 1) & fillTrailingOnes(rev_wire_max);
+        Kokkos::parallel_for(
+            Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits - 3)),
+            *this);
+    }
+    KOKKOS_FUNCTION void operator()(const std::size_t k) const {
+        const std::size_t i000 =
+            ((k << 3U) & parity_high) | ((k << 2U) & parity_hmiddle) |
+            ((k << 1U) & parity_lmiddle) | (k & parity_low);
+        const std::size_t i001 = i000 | rev_wire0_shift;
+        const std::size_t i010 = i000 | rev_wire1_shift;
+        const std::size_t i011 = i000 | rev_wire1_shift | rev_wire0_shift;
+        const std::size_t i100 = i000 | rev_wire2_shift;
+        const std::size_t i101 = i000 | rev_wire2_shift | rev_wire0_shift;
+        const std::size_t i110 = i000 | rev_wire2_shift | rev_wire1_shift;
+        const std::size_t i111 =
+            i000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
+        core_function(arr, i000, i001, i010, i011, i100, i101, i110, i111);
+    }
+};
+
+template <class ExecutionSpace, class PrecisionT>
+void applyCSWAP(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                const std::size_t num_qubits,
+                const std::vector<std::size_t> &wires,
+                [[maybe_unused]] const bool inverse = false,
+                [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC3Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i000,
+                      [[maybe_unused]] const std::size_t i001,
+                      [[maybe_unused]] const std::size_t i010,
+                      [[maybe_unused]] const std::size_t i011,
+                      [[maybe_unused]] const std::size_t i100,
+                      const std::size_t i101, const std::size_t i110,
+                      [[maybe_unused]] const std::size_t i111) {
+            swap(arr(i101), arr(i110));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyToffoli(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  [[maybe_unused]] const bool inverse = false,
+                  [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC3Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i000,
+                      [[maybe_unused]] const std::size_t i001,
+                      [[maybe_unused]] const std::size_t i010,
+                      [[maybe_unused]] const std::size_t i011,
+                      [[maybe_unused]] const std::size_t i100,
+                      [[maybe_unused]] const std::size_t i101,
+                      const std::size_t i110,
+                      const std::size_t i111) { swap(arr(i111), arr(i110)); });
+}
+
+template <class PrecisionT, class FuncT> class applyNC4Functor {
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
+    const FuncT core_function;
+    const std::size_t rev_wire0;
+    const std::size_t rev_wire1;
+    const std::size_t rev_wire2;
+    const std::size_t rev_wire3;
+    const std::size_t rev_wire0_shift;
+    const std::size_t rev_wire1_shift;
+    const std::size_t rev_wire2_shift;
+    const std::size_t rev_wire3_shift;
+    std::size_t parity_low;
+    std::size_t parity_high;
+    std::size_t parity_lmiddle;
+    std::size_t parity_hmiddle;
+    std::size_t parity_middle;
+
+  public:
+    template <class ExecutionSpace>
+    applyNC4Functor([[maybe_unused]] ExecutionSpace exec,
+                    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                    std::size_t num_qubits,
+                    const std::vector<std::size_t> &wires, FuncT core_function_)
+        : arr(arr_), core_function(core_function_),
+          rev_wire0(num_qubits - wires[3] - 1),
+          rev_wire1(num_qubits - wires[2] - 1),
+          rev_wire2(num_qubits - wires[1] - 1),
+          rev_wire3(num_qubits - wires[0] - 1),
+          rev_wire0_shift(static_cast<std::size_t>(1U) << rev_wire0),
+          rev_wire1_shift(static_cast<std::size_t>(1U) << rev_wire1),
+          rev_wire2_shift(static_cast<std::size_t>(1U) << rev_wire2),
+          rev_wire3_shift(static_cast<std::size_t>(1U) << rev_wire3) {
+        std::size_t rev_wire_min = std::min(rev_wire0, rev_wire1);
+        std::size_t rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
+        std::size_t rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
+        std::size_t rev_wire_max = std::max(rev_wire2, rev_wire3);
+        if (rev_wire_max_mid > rev_wire_min_mid) {
+        } else if (rev_wire_max_mid < rev_wire_min) {
+            if (rev_wire_max < rev_wire_min) {
+                std::size_t tmp = rev_wire_min;
+                rev_wire_min = rev_wire_max_mid;
+                rev_wire_max_mid = tmp;
+
+                tmp = rev_wire_max;
+                rev_wire_max = rev_wire_min_mid;
+                rev_wire_min_mid = tmp;
+            } else if (rev_wire_max > rev_wire_min_mid) {
+                std::size_t tmp = rev_wire_min;
+                rev_wire_min = rev_wire_max_mid;
+                rev_wire_max_mid = rev_wire_min_mid;
+                rev_wire_min_mid = tmp;
+            } else {
+                std::size_t tmp = rev_wire_min;
+                rev_wire_min = rev_wire_max_mid;
+                rev_wire_max_mid = rev_wire_max;
+                rev_wire_max = rev_wire_min_mid;
+                rev_wire_min_mid = tmp;
+            }
+        } else {
+            if (rev_wire_max > rev_wire_min_mid) {
+                std::size_t tmp = rev_wire_min_mid;
+                rev_wire_min_mid = rev_wire_max_mid;
+                rev_wire_max_mid = tmp;
+            } else {
+                std::size_t tmp = rev_wire_min_mid;
+                rev_wire_min_mid = rev_wire_max_mid;
+                rev_wire_max_mid = rev_wire_max;
+                rev_wire_max = tmp;
+            }
+        }
+        parity_low = fillTrailingOnes(rev_wire_min);
+        parity_high = fillLeadingOnes(rev_wire_max + 1);
+        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
+                         fillTrailingOnes(rev_wire_min_mid);
+        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
+                         fillTrailingOnes(rev_wire_max);
+        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
+                        fillTrailingOnes(rev_wire_max_mid);
+        Kokkos::parallel_for(
+            Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits - 4)),
+            *this);
+    }
+    KOKKOS_FUNCTION void operator()(const std::size_t k) const {
+        const std::size_t i0000 =
+            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
+            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
+            (k & parity_low);
+        const std::size_t i0001 = i0000 | rev_wire0_shift;
+        const std::size_t i0010 = i0000 | rev_wire1_shift;
+        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
+        const std::size_t i0100 = i0000 | rev_wire2_shift;
+        const std::size_t i0101 = i0000 | rev_wire2_shift | rev_wire0_shift;
+        const std::size_t i0110 = i0000 | rev_wire2_shift | rev_wire1_shift;
+        const std::size_t i0111 =
+            i0000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
+        const std::size_t i1000 = i0000 | rev_wire3_shift;
+        const std::size_t i1001 = i0000 | rev_wire3_shift | rev_wire0_shift;
+        const std::size_t i1010 = i0000 | rev_wire3_shift | rev_wire1_shift;
+        const std::size_t i1011 =
+            i0000 | rev_wire3_shift | rev_wire1_shift | rev_wire0_shift;
+        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
+        const std::size_t i1101 =
+            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire0_shift;
+        const std::size_t i1110 =
+            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire1_shift;
+        const std::size_t i1111 = i0000 | rev_wire3_shift | rev_wire2_shift |
+                                  rev_wire1_shift | rev_wire0_shift;
+        core_function(arr, i0000, i0001, i0010, i0011, i0100, i0101, i0110,
+                      i0111, i1000, i1001, i1010, i1011, i1100, i1101, i1110,
+                      i1111);
+    }
+};
+
+template <class ExecutionSpace, class PrecisionT>
+void applyDoubleExcitation(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                           const std::size_t num_qubits,
+                           const std::vector<std::size_t> &wires,
+                           const bool inverse = false,
+                           const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj =
+        (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(
+            Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+            [[maybe_unused]] const std::size_t i0000,
+            [[maybe_unused]] const std::size_t i0001,
+            [[maybe_unused]] const std::size_t i0010, const std::size_t i0011,
+            [[maybe_unused]] const std::size_t i0100,
+            [[maybe_unused]] const std::size_t i0101,
+            [[maybe_unused]] const std::size_t i0110,
+            [[maybe_unused]] const std::size_t i0111,
+            [[maybe_unused]] const std::size_t i1000,
+            [[maybe_unused]] const std::size_t i1001,
+            [[maybe_unused]] const std::size_t i1010,
+            [[maybe_unused]] const std::size_t i1011, const std::size_t i1100,
+            [[maybe_unused]] const std::size_t i1101,
+            [[maybe_unused]] const std::size_t i1110,
+            [[maybe_unused]] const std::size_t i1111) {
+            const Kokkos::complex<PrecisionT> v3 = arr(i0011);
+            const Kokkos::complex<PrecisionT> v12 = arr(i1100);
+            arr(i0011) = cr * v3 - sj * v12;
+            arr(i1100) = sj * v3 + cr * v12;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyDoubleExcitationMinus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    const bool inverse = false, const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
+    const Kokkos::complex<PrecisionT> e =
+        inverse ? exp(Kokkos::complex<PrecisionT>(0, angle / 2))
+                : exp(Kokkos::complex<PrecisionT>(0, -angle / 2));
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0000, const std::size_t i0001,
+                      const std::size_t i0010, const std::size_t i0011,
+                      const std::size_t i0100, const std::size_t i0101,
+                      const std::size_t i0110, const std::size_t i0111,
+                      const std::size_t i1000, const std::size_t i1001,
+                      const std::size_t i1010, const std::size_t i1011,
+                      const std::size_t i1100, const std::size_t i1101,
+                      const std::size_t i1110, const std::size_t i1111) {
+            const Kokkos::complex<PrecisionT> v3 = arr(i0011);
+            const Kokkos::complex<PrecisionT> v12 = arr(i1100);
+            arr(i0000) *= e;
+            arr(i0001) *= e;
+            arr(i0010) *= e;
+            arr(i0011) = cr * v3 - sj * v12;
+            arr(i0100) *= e;
+            arr(i0101) *= e;
+            arr(i0110) *= e;
+            arr(i0111) *= e;
+            arr(i1000) *= e;
+            arr(i1001) *= e;
+            arr(i1010) *= e;
+            arr(i1011) *= e;
+            arr(i1100) = sj * v3 + cr * v12;
+            arr(i1101) *= e;
+            arr(i1110) *= e;
+            arr(i1111) *= e;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyDoubleExcitationPlus(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                               const std::size_t num_qubits,
+                               const std::vector<std::size_t> &wires,
+                               const bool inverse = false,
+                               const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const PrecisionT cr = std::cos(angle / 2);
+    const PrecisionT sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
+    const Kokkos::complex<PrecisionT> e =
+        inverse ? exp(Kokkos::complex<PrecisionT>(0, -angle / 2))
+                : exp(Kokkos::complex<PrecisionT>(0, angle / 2));
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0000, const std::size_t i0001,
+                      const std::size_t i0010, const std::size_t i0011,
+                      const std::size_t i0100, const std::size_t i0101,
+                      const std::size_t i0110, const std::size_t i0111,
+                      const std::size_t i1000, const std::size_t i1001,
+                      const std::size_t i1010, const std::size_t i1011,
+                      const std::size_t i1100, const std::size_t i1101,
+                      const std::size_t i1110, const std::size_t i1111) {
+            const Kokkos::complex<PrecisionT> v3 = arr(i0011);
+            const Kokkos::complex<PrecisionT> v12 = arr(i1100);
+            arr(i0000) *= e;
+            arr(i0001) *= e;
+            arr(i0010) *= e;
+            arr(i0011) = cr * v3 - sj * v12;
+            arr(i0100) *= e;
+            arr(i0101) *= e;
+            arr(i0110) *= e;
+            arr(i0111) *= e;
+            arr(i1000) *= e;
+            arr(i1001) *= e;
+            arr(i1010) *= e;
+            arr(i1011) *= e;
+            arr(i1100) = sj * v3 + cr * v12;
+            arr(i1101) *= e;
+            arr(i1110) *= e;
+            arr(i1111) *= e;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyMultiRZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                  const std::size_t num_qubits,
+                  const std::vector<std::size_t> &wires,
+                  const bool inverse = false,
+                  const std::vector<PrecisionT> &params = {}) {
+    const PrecisionT &angle = params[0];
+    const Kokkos::complex<PrecisionT> shift_0 = Kokkos::complex<PrecisionT>{
+        std::cos(angle / 2),
+        (inverse) ? std::sin(angle / 2) : -std::sin(angle / 2)};
+    const Kokkos::complex<PrecisionT> shift_1 = conj(shift_0);
+    std::size_t wires_parity = 0U;
+    for (std::size_t wire : wires) {
+        wires_parity |=
+            (static_cast<std::size_t>(1U) << (num_qubits - wire - 1));
+    }
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits)),
+        KOKKOS_LAMBDA(const std::size_t k) {
+            arr_(k) *= (Kokkos::Impl::bit_count(k & wires_parity) % 2 == 0)
+                           ? shift_0
+                           : shift_1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGlobalPhase(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                      const std::size_t num_qubits,
+                      [[maybe_unused]] const std::vector<std::size_t> &wires,
+                      const bool inverse = false,
+                      const std::vector<PrecisionT> &params = {}) {
+    const Kokkos::complex<PrecisionT> phase = Kokkos::exp(
+        Kokkos::complex<PrecisionT>{0, (inverse) ? params[0] : -params[0]});
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits)),
+        KOKKOS_LAMBDA(const std::size_t k) { arr_(k) *= phase; });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyNamedOperation(const GateOperation gateop,
+                         Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                         const std::size_t num_qubits,
+                         const std::vector<std::size_t> &wires,
+                         const bool inverse = false,
+                         const std::vector<PrecisionT> &params = {}) {
+    switch (gateop) {
+    case GateOperation::PauliX:
+        applyPauliX<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::PauliY:
+        applyPauliY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::PauliZ:
+        applyPauliZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::Hadamard:
+        applyHadamard<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::S:
+        applyS<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::T:
+        applyT<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::PhaseShift:
+        applyPhaseShift<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return;
+    case GateOperation::RX:
+        applyRX<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::RY:
+        applyRY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::RZ:
+        applyRZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::Rot:
+        applyRot<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CNOT:
+        applyCNOT<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CY:
+        applyCY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CZ:
+        applyCZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::SWAP:
+        applySWAP<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::ControlledPhaseShift:
+        applyControlledPhaseShift<ExecutionSpace>(arr_, num_qubits, wires,
+                                                  inverse, params);
+        return;
+    case GateOperation::CRX:
+        applyCRX<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CRY:
+        applyCRY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CRZ:
+        applyCRZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::CRot:
+        applyCRot<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::IsingXX:
+        applyIsingXX<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::IsingXY:
+        applyIsingXY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::IsingYY:
+        applyIsingYY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::IsingZZ:
+        applyIsingZZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::SingleExcitation:
+        applySingleExcitation<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                              params);
+        return;
+    case GateOperation::SingleExcitationMinus:
+        applySingleExcitationMinus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                   inverse, params);
+        return;
+    case GateOperation::SingleExcitationPlus:
+        applySingleExcitationPlus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                  inverse, params);
+        return;
+    case GateOperation::CSWAP:
+        applyCSWAP<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::Toffoli:
+        applyToffoli<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    case GateOperation::DoubleExcitation:
+        applyDoubleExcitation<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                              params);
+        return;
+    case GateOperation::DoubleExcitationMinus:
+        applyDoubleExcitationMinus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                   inverse, params);
+        return;
+    case GateOperation::DoubleExcitationPlus:
+        applyDoubleExcitationPlus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                  inverse, params);
+        return;
+    case GateOperation::GlobalPhase:
+        applyGlobalPhase<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                         params);
+        return;
+    case GateOperation::MultiRZ:
+        applyMultiRZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return;
+    default:
+        PL_ABORT("Gate operation does not exist.");
+    }
+}
+
+} // namespace Pennylane::LightningKokkos::Functors
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGeneratorFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGeneratorFunctors.hpp
new file mode 100644
index 0000000000..76fd3f112a
--- /dev/null
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/BasicGeneratorFunctors.hpp
@@ -0,0 +1,453 @@
+// Copyright 2018-2024 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an AS IS BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_StdAlgorithms.hpp>
+
+#include "BasicGateFunctors.hpp"
+#include "BitUtil.hpp"
+#include "GateOperation.hpp"
+
+/// @cond DEV
+namespace {
+using namespace Pennylane::Util;
+using Kokkos::Experimental::swap;
+using Pennylane::Gates::GeneratorOperation;
+} // namespace
+/// @endcond
+
+namespace Pennylane::LightningKokkos::Functors {
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenPhaseShift(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC1Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0,
+                      [[maybe_unused]] const std::size_t i1) {
+            arr(i0) = ZERO<Kokkos::complex, PrecisionT>();
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenControlledPhaseShift(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i01) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i10) = ZERO<Kokkos::complex, PrecisionT>();
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenCRX(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i01) = ZERO<Kokkos::complex, PrecisionT>();
+            swap(arr(i10), arr(i11));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenCRY(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i01) = ZERO<Kokkos::complex, PrecisionT>();
+            const auto v0 = arr(i10);
+            arr(i10) =
+                Kokkos::complex<PrecisionT>{imag(arr(i11)), -real(arr(i11))};
+            arr(i11) = Kokkos::complex<PrecisionT>{-imag(v0), real(v0)};
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenCRZ(Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                 const std::size_t num_qubits,
+                 const std::vector<std::size_t> &wires,
+                 [[maybe_unused]] const bool inverse = false,
+                 [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      [[maybe_unused]] const std::size_t i10,
+                      const std::size_t i11) {
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i01) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i11) *= -1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenIsingXX(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            swap(arr(i00), arr(i11));
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenIsingXY(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            swap(arr(i10), arr(i01));
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i11) = ZERO<Kokkos::complex, PrecisionT>();
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenIsingYY(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            const auto v00 = arr(i00);
+            arr(i00) = -arr(i11);
+            arr(i11) = -v00;
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenIsingZZ(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            arr(i10) *= -1;
+            arr(i01) *= -1;
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenSingleExcitation(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i00, const std::size_t i01,
+                      const std::size_t i10, const std::size_t i11) {
+            arr(i00) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i01) *= IMAG<Kokkos::complex, PrecisionT>();
+            arr(i10) *= -IMAG<Kokkos::complex, PrecisionT>();
+            arr(i11) = ZERO<Kokkos::complex, PrecisionT>();
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenSingleExcitationMinus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            arr(i01) *= IMAG<Kokkos::complex, PrecisionT>();
+            arr(i10) *= -IMAG<Kokkos::complex, PrecisionT>();
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenSingleExcitationPlus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC2Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      [[maybe_unused]] const std::size_t i00,
+                      const std::size_t i01, const std::size_t i10,
+                      [[maybe_unused]] const std::size_t i11) {
+            arr(i00) *= -1;
+            arr(i01) *= IMAG<Kokkos::complex, PrecisionT>();
+            arr(i10) *= -IMAG<Kokkos::complex, PrecisionT>();
+            arr(i11) *= -1;
+            swap(arr(i10), arr(i01));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenDoubleExcitation(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+                      const std::size_t i0000, const std::size_t i0001,
+                      const std::size_t i0010, const std::size_t i0011,
+                      const std::size_t i0100, const std::size_t i0101,
+                      const std::size_t i0110, const std::size_t i0111,
+                      const std::size_t i1000, const std::size_t i1001,
+                      const std::size_t i1010, const std::size_t i1011,
+                      const std::size_t i1100, const std::size_t i1101,
+                      const std::size_t i1110, const std::size_t i1111) {
+            const Kokkos::complex<PrecisionT> v3 = arr(i0011);
+            const Kokkos::complex<PrecisionT> v12 = arr(i1100);
+            arr(i0000) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0001) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0010) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0011) = v12 * -IMAG<Kokkos::complex, PrecisionT>();
+            arr(i0100) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0101) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0110) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i0111) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1000) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1001) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1010) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1011) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1100) = v3 * IMAG<Kokkos::complex, PrecisionT>();
+            arr(i1101) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1110) = ZERO<Kokkos::complex, PrecisionT>();
+            arr(i1111) = ZERO<Kokkos::complex, PrecisionT>();
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenDoubleExcitationMinus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(
+            Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+            [[maybe_unused]] const std::size_t i0000,
+            [[maybe_unused]] const std::size_t i0001,
+            [[maybe_unused]] const std::size_t i0010, const std::size_t i0011,
+            [[maybe_unused]] const std::size_t i0100,
+            [[maybe_unused]] const std::size_t i0101,
+            [[maybe_unused]] const std::size_t i0110,
+            [[maybe_unused]] const std::size_t i0111,
+            [[maybe_unused]] const std::size_t i1000,
+            [[maybe_unused]] const std::size_t i1001,
+            [[maybe_unused]] const std::size_t i1010,
+            [[maybe_unused]] const std::size_t i1011, const std::size_t i1100,
+            [[maybe_unused]] const std::size_t i1101,
+            [[maybe_unused]] const std::size_t i1110,
+            [[maybe_unused]] const std::size_t i1111) {
+            arr(i0011) *= IMAG<Kokkos::complex, PrecisionT>();
+            arr(i1100) *= -IMAG<Kokkos::complex, PrecisionT>();
+            swap(arr(i1100), arr(i0011));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenDoubleExcitationPlus(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    applyNC4Functor(
+        ExecutionSpace{}, arr_, num_qubits, wires,
+        KOKKOS_LAMBDA(
+            Kokkos::View<Kokkos::complex<PrecisionT> *> arr,
+            [[maybe_unused]] const std::size_t i0000,
+            [[maybe_unused]] const std::size_t i0001,
+            [[maybe_unused]] const std::size_t i0010, const std::size_t i0011,
+            [[maybe_unused]] const std::size_t i0100,
+            [[maybe_unused]] const std::size_t i0101,
+            [[maybe_unused]] const std::size_t i0110,
+            [[maybe_unused]] const std::size_t i0111,
+            [[maybe_unused]] const std::size_t i1000,
+            [[maybe_unused]] const std::size_t i1001,
+            [[maybe_unused]] const std::size_t i1010,
+            [[maybe_unused]] const std::size_t i1011, const std::size_t i1100,
+            [[maybe_unused]] const std::size_t i1101,
+            [[maybe_unused]] const std::size_t i1110,
+            [[maybe_unused]] const std::size_t i1111) {
+            arr(i0011) *= -IMAG<Kokkos::complex, PrecisionT>();
+            arr(i1100) *= IMAG<Kokkos::complex, PrecisionT>();
+            swap(arr(i1100), arr(i0011));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+void applyGenMultiRZ(
+    Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+    const std::size_t num_qubits, const std::vector<std::size_t> &wires,
+    [[maybe_unused]] const bool inverse = false,
+    [[maybe_unused]] const std::vector<PrecisionT> &params = {}) {
+    std::size_t wires_parity = static_cast<std::size_t>(0U);
+    for (std::size_t wire : wires) {
+        wires_parity |=
+            (static_cast<std::size_t>(1U) << (num_qubits - wire - 1));
+    }
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecutionSpace>(0, exp2(num_qubits)),
+        KOKKOS_LAMBDA(const std::size_t k) {
+            arr_(k) *= static_cast<PrecisionT>(
+                1 - 2 * int(Kokkos::Impl::bit_count(k & wires_parity) % 2));
+        });
+}
+
+template <class ExecutionSpace, class PrecisionT>
+PrecisionT applyNamedGenerator(const GeneratorOperation generator_op,
+                               Kokkos::View<Kokkos::complex<PrecisionT> *> arr_,
+                               const std::size_t num_qubits,
+                               const std::vector<std::size_t> &wires,
+                               const bool inverse = false,
+                               const std::vector<PrecisionT> &params = {}) {
+    switch (generator_op) {
+    case GeneratorOperation::RX:
+        applyNamedOperation<ExecutionSpace>(GateOperation::PauliX, arr_,
+                                            num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::RY:
+        applyNamedOperation<ExecutionSpace>(GateOperation::PauliY, arr_,
+                                            num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::RZ:
+        applyNamedOperation<ExecutionSpace>(GateOperation::PauliZ, arr_,
+                                            num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::PhaseShift:
+        applyGenPhaseShift<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                           params);
+        return static_cast<PrecisionT>(1.0);
+    case GeneratorOperation::ControlledPhaseShift:
+        applyGenControlledPhaseShift<ExecutionSpace>(arr_, num_qubits, wires,
+                                                     inverse, params);
+        return static_cast<PrecisionT>(1);
+    case GeneratorOperation::CRX:
+        applyGenCRX<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::CRY:
+        applyGenCRY<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::CRZ:
+        applyGenCRZ<ExecutionSpace>(arr_, num_qubits, wires, inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::IsingXX:
+        applyGenIsingXX<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::IsingXY:
+        applyGenIsingXY<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::IsingYY:
+        applyGenIsingYY<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::IsingZZ:
+        applyGenIsingZZ<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::SingleExcitation:
+        applyGenSingleExcitation<ExecutionSpace>(arr_, num_qubits, wires,
+                                                 inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::SingleExcitationMinus:
+        applyGenSingleExcitationMinus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                      inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::SingleExcitationPlus:
+        applyGenSingleExcitationPlus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                     inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::DoubleExcitation:
+        applyGenDoubleExcitation<ExecutionSpace>(arr_, num_qubits, wires,
+                                                 inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::DoubleExcitationMinus:
+        applyGenDoubleExcitationMinus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                      inverse, params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::DoubleExcitationPlus:
+        applyGenDoubleExcitationPlus<ExecutionSpace>(arr_, num_qubits, wires,
+                                                     inverse, params);
+        return static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::MultiRZ:
+        applyGenMultiRZ<ExecutionSpace>(arr_, num_qubits, wires, inverse,
+                                        params);
+        return -static_cast<PrecisionT>(0.5);
+    case GeneratorOperation::GlobalPhase:
+        return static_cast<PrecisionT>(-1.0);
+    /// LCOV_EXCL_START
+    default:
+        PL_ABORT("Generator operation does not exist.");
+        /// LCOV_EXCL_STOP
+    }
+}
+
+} // namespace Pennylane::LightningKokkos::Functors
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctors.hpp
index 3df6284eca..95de4d959d 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctors.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctors.hpp
@@ -13,6 +13,6 @@
 // limitations under the License.
 #pragma once
 
-#include "GateFunctorsGenerator.hpp"
-#include "GateFunctorsNonparam.hpp"
-#include "GateFunctorsParam.hpp"
+#include "BasicGateFunctors.hpp"
+#include "BasicGeneratorFunctors.hpp"
+#include "MatrixGateFunctors.hpp"
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsGenerator.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsGenerator.hpp
deleted file mode 100644
index bd08b3baab..0000000000
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsGenerator.hpp
+++ /dev/null
@@ -1,976 +0,0 @@
-// Copyright 2018-2023 Xanadu Quantum Technologies Inc.
-
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-// http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_StdAlgorithms.hpp>
-
-#include "BitUtil.hpp"
-
-/// @cond DEV
-namespace {
-using namespace Pennylane::Util;
-using Kokkos::Experimental::swap;
-} // namespace
-/// @endcond
-
-namespace Pennylane::LightningKokkos::Functors {
-template <class PrecisionT, bool adj = false>
-struct generatorPhaseShiftFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    generatorPhaseShiftFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        arr[i0] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorIsingXXFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorIsingXXFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        swap(arr[i00], arr[i11]);
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorIsingXYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorIsingXYFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        swap(arr[i10], arr[i01]);
-        arr[i00] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-        arr[i11] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorIsingYYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorIsingYYFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const auto v00 = arr[i00];
-        arr[i00] = -arr[i11];
-        arr[i11] = -v00;
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorIsingZZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorIsingZZFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-
-        arr[i10] *= -1;
-        arr[i01] *= -1;
-    }
-};
-
-template <class PrecisionT, bool adj = false>
-struct generatorSingleExcitationFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorSingleExcitationFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] = ComplexT{};
-        arr[i01] *= ComplexT{0, 1};
-        arr[i10] *= ComplexT{0, -1};
-        arr[i11] = ComplexT{};
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool adj = false>
-struct generatorSingleExcitationMinusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorSingleExcitationMinusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-
-        arr[i01] *= ComplexT{0, 1};
-        arr[i10] *= ComplexT{0, -1};
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool adj = false>
-struct generatorSingleExcitationPlusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorSingleExcitationPlusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] *= -1;
-        arr[i01] *= ComplexT{0, 1};
-        arr[i10] *= ComplexT{0, -1};
-        arr[i11] *= -1;
-
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct generatorDoubleExcitationFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    generatorDoubleExcitationFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0001 = i0000 | rev_wire0_shift;
-        const std::size_t i0010 = i0000 | rev_wire1_shift;
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i0100 = i0000 | rev_wire2_shift;
-        const std::size_t i0101 = i0000 | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i0110 = i0000 | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i0111 =
-            i0000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1000 = i0000 | rev_wire3_shift;
-        const std::size_t i1001 = i0000 | rev_wire3_shift | rev_wire0_shift;
-        const std::size_t i1010 = i0000 | rev_wire3_shift | rev_wire1_shift;
-        const std::size_t i1011 =
-            i0000 | rev_wire3_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-        const std::size_t i1101 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i1110 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i1111 = i0000 | rev_wire3_shift | rev_wire2_shift |
-                                  rev_wire1_shift | rev_wire0_shift;
-
-        const Kokkos::complex<PrecisionT> v3 = arr[i0011];
-        const Kokkos::complex<PrecisionT> v12 = arr[i1100];
-        arr[i0000] = ComplexT{};
-        arr[i0001] = ComplexT{};
-        arr[i0010] = ComplexT{};
-        arr[i0011] = v12 * ComplexT{0, -1};
-        arr[i0100] = ComplexT{};
-        arr[i0101] = ComplexT{};
-        arr[i0110] = ComplexT{};
-        arr[i0111] = ComplexT{};
-        arr[i1000] = ComplexT{};
-        arr[i1001] = ComplexT{};
-        arr[i1010] = ComplexT{};
-        arr[i1011] = ComplexT{};
-        arr[i1100] = v3 * ComplexT{0, 1};
-        arr[i1101] = ComplexT{};
-        arr[i1110] = ComplexT{};
-        arr[i1111] = ComplexT{};
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct generatorDoubleExcitationMinusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    generatorDoubleExcitationMinusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-
-        arr[i0011] *= ComplexT{0, 1};
-        arr[i1100] *= ComplexT{0, -1};
-        swap(arr[i1100], arr[i0011]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct generatorDoubleExcitationPlusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    generatorDoubleExcitationPlusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-
-        arr[i0011] *= ComplexT{0, -1};
-        arr[i1100] *= ComplexT{0, 1};
-        swap(arr[i1100], arr[i0011]);
-    }
-};
-
-template <class PrecisionT, bool adj = false>
-struct generatorControlledPhaseShiftFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorControlledPhaseShiftFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-
-        arr[i00] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-        arr[i01] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-        arr[i10] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorCRXFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorCRXFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-        arr[i01] = Kokkos::complex<PrecisionT>{0.0, 0.0};
-        swap(arr[i10], arr[i11]);
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorCRYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorCRYFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] = ComplexT{};
-        arr[i01] = ComplexT{};
-
-        const auto v0 = arr[i10];
-
-        arr[i10] = ComplexT{imag(arr[i11]), -real(arr[i11])};
-        arr[i11] = ComplexT{-imag(v0), real(v0)};
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorCRZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    generatorCRZFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        using ComplexT = Kokkos::complex<PrecisionT>;
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] = ComplexT{};
-        arr[i01] = ComplexT{};
-        arr[i11] *= -1;
-    }
-};
-
-template <class PrecisionT, bool adj = false> struct generatorMultiRZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t wires_parity;
-
-    generatorMultiRZFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                            std::size_t num_qubits,
-                            const std::vector<std::size_t> &wires) {
-        arr = arr_;
-        wires_parity = static_cast<std::size_t>(0U);
-        for (size_t wire : wires) {
-            wires_parity |=
-                (static_cast<std::size_t>(1U) << (num_qubits - wire - 1));
-        }
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        arr[k] *= static_cast<PrecisionT>(
-            1 - 2 * int(Kokkos::Impl::bit_count(k & wires_parity) % 2));
-    }
-};
-
-} // namespace Pennylane::LightningKokkos::Functors
\ No newline at end of file
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsNonparam.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsNonparam.hpp
deleted file mode 100644
index 63ba5f1d8c..0000000000
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsNonparam.hpp
+++ /dev/null
@@ -1,532 +0,0 @@
-// Copyright 2018-2023 Xanadu Quantum Technologies Inc.
-
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-// http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_StdAlgorithms.hpp>
-
-#include "BitUtil.hpp"
-
-/// @cond DEV
-namespace {
-using namespace Pennylane::Util;
-using Kokkos::Experimental::swap;
-} // namespace
-/// @endcond
-
-namespace Pennylane::LightningKokkos::Functors {
-template <class PrecisionT, bool inverse = false> struct hadamardFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    hadamardFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                    std::size_t num_qubits,
-                    const std::vector<std::size_t> &wires,
-                    [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        if constexpr (inverse) {
-            const std::size_t i0 =
-                ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-            const std::size_t i1 = i0 | rev_wire_shift;
-            const Kokkos::complex<PrecisionT> v0 = arr[i0];
-            const Kokkos::complex<PrecisionT> v1 = arr[i1];
-            arr[i0] = M_SQRT1_2 * v0 +
-                      M_SQRT1_2 * v1; // NOLINT(readability-magic-numbers)
-            arr[i1] = M_SQRT1_2 * v0 +
-                      (-M_SQRT1_2) * v1; // NOLINT(readability-magic-numbers)
-                                         // }
-        } else {
-            const std::size_t i0 =
-                ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-            const std::size_t i1 = i0 | rev_wire_shift;
-            const Kokkos::complex<PrecisionT> v0 = arr[i0];
-            const Kokkos::complex<PrecisionT> v1 = arr[i1];
-            arr[i0] = M_SQRT1_2 * v0 +
-                      M_SQRT1_2 * v1; // NOLINT(readability-magic-numbers)
-            arr[i1] = M_SQRT1_2 * v0 +
-                      -M_SQRT1_2 * v1; // NOLINT(readability-magic-numbers)
-                                       // }
-        }
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct pauliXFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    pauliXFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                  std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                  [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        swap(arr[i0], arr[i1]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct pauliYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    pauliYFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                  std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                  [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        const auto v0 = arr[i0];
-        const auto v1 = arr[i1];
-        arr[i0] = Kokkos::complex<PrecisionT>{imag(v1), -real(v1)};
-        arr[i1] = Kokkos::complex<PrecisionT>{-imag(v0), real(v0)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct pauliZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    pauliZFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                  std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                  [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        arr[i1] *= -1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct sFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    Kokkos::complex<PrecisionT> shift;
-
-    sFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-             std::size_t num_qubits, const std::vector<std::size_t> &wires,
-             [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        shift =
-            (inverse) ? -Kokkos::complex{0.0, 1.0} : Kokkos::complex{0.0, 1.0};
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        arr[i1] *= shift;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct tFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    Kokkos::complex<PrecisionT> shift;
-
-    tFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-             std::size_t num_qubits, const std::vector<std::size_t> &wires,
-             [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        shift = (inverse) ? conj(exp(Kokkos::complex<PrecisionT>(
-                                0, static_cast<PrecisionT>(M_PI / 4))))
-                          : exp(Kokkos::complex<PrecisionT>(
-                                0, static_cast<PrecisionT>(M_PI / 4)));
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        arr[i1] *= shift;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct cnotFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    cnotFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire1_shift | rev_wire0_shift;
-
-        swap(arr[i10], arr[i11]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct cyFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    cyFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-              std::size_t num_qubits, const std::vector<std::size_t> &wires,
-              [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire1_shift | rev_wire0_shift;
-        Kokkos::complex<PrecisionT> v10 = arr[i10];
-        arr[i10] = Kokkos::complex<PrecisionT>{imag(arr[i11]), -real(arr[i11])};
-        arr[i11] = Kokkos::complex<PrecisionT>{-imag(v10), real(v10)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct czFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    czFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-              std::size_t num_qubits, const std::vector<std::size_t> &wires,
-              [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-        arr[i11] *= -1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct swapFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    swapFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        swap(arr[i10], arr[i01]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct cSWAPFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-
-    cSWAPFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                 std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                 [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[2] - 1;
-        rev_wire1 = num_qubits - wires[1] - 1;
-        rev_wire2 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        if (rev_wire2 < rev_wire_min) {
-            rev_wire_mid = rev_wire_min;
-            rev_wire_min = rev_wire2;
-        } else if (rev_wire2 > rev_wire_max) {
-            rev_wire_mid = rev_wire_max;
-            rev_wire_max = rev_wire2;
-        } else {
-            rev_wire_mid = rev_wire2;
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_mid);
-        parity_hmiddle =
-            fillLeadingOnes(rev_wire_mid + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i000 =
-            ((k << 3U) & parity_high) | ((k << 2U) & parity_hmiddle) |
-            ((k << 1U) & parity_lmiddle) | (k & parity_low);
-        const std::size_t i101 = i000 | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i110 = i000 | rev_wire2_shift | rev_wire1_shift;
-
-        swap(arr[i101], arr[i110]);
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct toffoliFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-
-    toffoliFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   [[maybe_unused]] const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[2] - 1;
-        rev_wire1 = num_qubits - wires[1] - 1;
-        rev_wire2 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        if (rev_wire2 < rev_wire_min) {
-            rev_wire_mid = rev_wire_min;
-            rev_wire_min = rev_wire2;
-        } else if (rev_wire2 > rev_wire_max) {
-            rev_wire_mid = rev_wire_max;
-            rev_wire_max = rev_wire2;
-        } else {
-            rev_wire_mid = rev_wire2;
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_mid);
-        parity_hmiddle =
-            fillLeadingOnes(rev_wire_mid + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i000 =
-            ((k << 3U) & parity_high) | ((k << 2U) & parity_hmiddle) |
-            ((k << 1U) & parity_lmiddle) | (k & parity_low);
-        const std::size_t i111 =
-            i000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i110 = i000 | rev_wire2_shift | rev_wire1_shift;
-
-        swap(arr[i111], arr[i110]);
-    }
-};
-
-} // namespace Pennylane::LightningKokkos::Functors
\ No newline at end of file
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsParam.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsParam.hpp
deleted file mode 100644
index 8dc50a262c..0000000000
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/GateFunctorsParam.hpp
+++ /dev/null
@@ -1,1972 +0,0 @@
-// Copyright 2018-2023 Xanadu Quantum Technologies Inc.
-
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-// http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_StdAlgorithms.hpp>
-
-#include "BitUtil.hpp"
-#include "BitUtilKokkos.hpp"
-
-/// @cond DEV
-namespace {
-using namespace Pennylane::Util;
-using Kokkos::Experimental::swap;
-using Pennylane::LightningKokkos::Util::one;
-using Pennylane::LightningKokkos::Util::wires2Parity;
-using std::size_t;
-} // namespace
-/// @endcond
-
-namespace Pennylane::LightningKokkos::Functors {
-
-template <class Precision> struct multiQubitOpFunctor {
-    using KokkosComplexVector = Kokkos::View<Kokkos::complex<Precision> *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-    using ScratchViewComplex =
-        Kokkos::View<Kokkos::complex<Precision> *,
-                     Kokkos::DefaultExecutionSpace::scratch_memory_space,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
-    using ScratchViewSizeT =
-        Kokkos::View<std::size_t *,
-                     Kokkos::DefaultExecutionSpace::scratch_memory_space,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
-    using MemberType = Kokkos::TeamPolicy<>::member_type;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    KokkosIntVector wires;
-    KokkosIntVector parity;
-    KokkosIntVector rev_wire_shifts;
-    std::size_t dim;
-    std::size_t num_qubits;
-
-    multiQubitOpFunctor(KokkosComplexVector &arr_, std::size_t num_qubits_,
-                        const KokkosComplexVector &matrix_,
-                        const std::vector<std::size_t> &wires_) {
-        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-            wires_host(wires_.data(), wires_.size());
-        Kokkos::resize(wires, wires_host.size());
-        Kokkos::deep_copy(wires, wires_host);
-        dim = one << wires_.size();
-        num_qubits = num_qubits_;
-        arr = arr_;
-        matrix = matrix_;
-        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const MemberType &teamMember) const {
-        const std::size_t k = teamMember.league_rank();
-        ScratchViewComplex coeffs_in(teamMember.team_scratch(0), dim);
-        ScratchViewSizeT indices(teamMember.team_scratch(0), dim);
-        if (teamMember.team_rank() == 0) {
-            std::size_t idx = (k & parity(0));
-            for (std::size_t i = 1; i < parity.size(); i++) {
-                idx |= ((k << i) & parity(i));
-            }
-            indices(0) = idx;
-            coeffs_in(0) = arr(idx);
-
-            Kokkos::parallel_for(Kokkos::ThreadVectorRange(teamMember, 1, dim),
-                                 [&](const std::size_t inner_idx) {
-                                     std::size_t index = indices(0);
-                                     for (std::size_t i = 0; i < wires.size();
-                                          i++) {
-                                         if ((inner_idx & (one << i)) != 0) {
-                                             index |= rev_wire_shifts(i);
-                                         }
-                                     }
-                                     indices(inner_idx) = index;
-                                     coeffs_in(inner_idx) = arr(index);
-                                 });
-        }
-        teamMember.team_barrier();
-        Kokkos::parallel_for(
-            Kokkos::TeamThreadRange(teamMember, dim), [&](const std::size_t i) {
-                const auto idx = indices(i);
-                arr(idx) = 0.0;
-                const std::size_t base_idx = i * dim;
-
-                for (std::size_t j = 0; j < dim; j++) {
-                    arr(idx) += matrix(base_idx + j) * coeffs_in(j);
-                }
-            });
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct phaseShiftFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    Kokkos::complex<PrecisionT> s;
-
-    phaseShiftFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                      std::size_t num_qubits,
-                      const std::vector<std::size_t> &wires,
-                      const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        const PrecisionT &angle = params[0];
-
-        s = inverse ? exp(-Kokkos::complex<PrecisionT>(0, angle))
-                    : exp(Kokkos::complex<PrecisionT>(0, angle));
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        arr[i1] *= s;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct rxFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    PrecisionT c;
-    PrecisionT s;
-    rxFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-              std::size_t num_qubits, const std::vector<std::size_t> &wires,
-              const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        const PrecisionT &angle = params[0];
-        c = cos(angle * static_cast<PrecisionT>(0.5));
-        s = (inverse) ? sin(angle * static_cast<PrecisionT>(0.5))
-                      : sin(-angle * static_cast<PrecisionT>(0.5));
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        const auto v0 = arr[i0];
-        const auto v1 = arr[i1];
-
-        arr[i0] =
-            c * v0 + Kokkos::complex<PrecisionT>{-imag(v1) * s, real(v1) * s};
-        arr[i1] =
-            Kokkos::complex<PrecisionT>{-imag(v0) * s, real(v0) * s} + c * v1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct ryFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    PrecisionT c;
-    PrecisionT s;
-    ryFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-              std::size_t num_qubits, const std::vector<std::size_t> &wires,
-              const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        const PrecisionT &angle = params[0];
-        c = cos(angle * static_cast<PrecisionT>(0.5));
-        s = (inverse) ? -sin(angle * static_cast<PrecisionT>(0.5))
-                      : sin(angle * static_cast<PrecisionT>(0.5));
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        const auto v0 = arr[i0];
-        const auto v1 = arr[i1];
-
-        arr[i0] = Kokkos::complex<PrecisionT>{c * real(v0) - s * real(v1),
-                                              c * imag(v0) - s * imag(v1)};
-        arr[i1] = Kokkos::complex<PrecisionT>{s * real(v0) + c * real(v1),
-                                              s * imag(v0) + c * imag(v1)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct rzFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-    Kokkos::complex<PrecisionT> shift_0;
-    Kokkos::complex<PrecisionT> shift_1;
-
-    rzFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-              std::size_t num_qubits, const std::vector<std::size_t> &wires,
-              const std::vector<PrecisionT> &params) {
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-        const PrecisionT &angle = params[0];
-        PrecisionT cos_angle = cos(angle * static_cast<PrecisionT>(0.5));
-        PrecisionT sin_angle = sin(angle * static_cast<PrecisionT>(0.5));
-        Kokkos::complex<PrecisionT> first{cos_angle, -sin_angle};
-        Kokkos::complex<PrecisionT> second{cos_angle, sin_angle};
-        shift_0 = (inverse) ? Kokkos::conj(first) : first;
-        shift_1 = (inverse) ? Kokkos::conj(second) : second;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        arr[i0] *= shift_0;
-        arr[i1] *= shift_1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct cRotFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    Kokkos::complex<PrecisionT> rot_mat_0b00;
-    Kokkos::complex<PrecisionT> rot_mat_0b10;
-    Kokkos::complex<PrecisionT> rot_mat_0b01;
-    Kokkos::complex<PrecisionT> rot_mat_0b11;
-
-    cRotFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                std::size_t num_qubits, const std::vector<std::size_t> &wires,
-                const std::vector<PrecisionT> &params) {
-        const PrecisionT phi = (inverse) ? -params[2] : params[0];
-        const PrecisionT theta = (inverse) ? -params[1] : params[1];
-        const PrecisionT omega = (inverse) ? -params[0] : params[2];
-        const PrecisionT c = std::cos(theta / 2);
-        const PrecisionT s = std::sin(theta / 2);
-        const PrecisionT p{phi + omega};
-        const PrecisionT m{phi - omega};
-
-        auto imag = Kokkos::complex<PrecisionT>(0, 1);
-        rot_mat_0b00 =
-            Kokkos::exp(static_cast<PrecisionT>(p / 2) * (-imag)) * c;
-        rot_mat_0b01 = -Kokkos::exp(static_cast<PrecisionT>(m / 2) * imag) * s;
-        rot_mat_0b10 =
-            Kokkos::exp(static_cast<PrecisionT>(m / 2) * (-imag)) * s;
-        rot_mat_0b11 = Kokkos::exp(static_cast<PrecisionT>(p / 2) * imag) * c;
-
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const auto v0 = arr[i10];
-        const auto v1 = arr[i11];
-
-        arr[i10] = rot_mat_0b00 * v0 + rot_mat_0b01 * v1;
-        arr[i11] = rot_mat_0b10 * v0 + rot_mat_0b11 * v1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct isingXXFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-
-    isingXXFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v00 = arr[i00];
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr[i00] = Kokkos::complex<PrecisionT>{cr * real(v00) + sj * imag(v11),
-                                               cr * imag(v00) - sj * real(v11)};
-        arr[i01] = Kokkos::complex<PrecisionT>{cr * real(v01) + sj * imag(v10),
-                                               cr * imag(v01) - sj * real(v10)};
-        arr[i10] = Kokkos::complex<PrecisionT>{cr * real(v10) + sj * imag(v01),
-                                               cr * imag(v10) - sj * real(v01)};
-        arr[i11] = Kokkos::complex<PrecisionT>{cr * real(v11) + sj * imag(v00),
-                                               cr * imag(v11) - sj * real(v00)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct isingXYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-
-    isingXYFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v00 = arr[i00];
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr[i00] = Kokkos::complex<PrecisionT>{real(v00), imag(v00)};
-        arr[i01] = Kokkos::complex<PrecisionT>{cr * real(v01) - sj * imag(v10),
-                                               cr * imag(v01) + sj * real(v10)};
-        arr[i10] = Kokkos::complex<PrecisionT>{cr * real(v10) - sj * imag(v01),
-                                               cr * imag(v10) + sj * real(v01)};
-        arr[i11] = Kokkos::complex<PrecisionT>{real(v11), imag(v11)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct isingYYFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-
-    isingYYFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v00 = arr[i00];
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr[i00] = Kokkos::complex<PrecisionT>{cr * real(v00) - sj * imag(v11),
-                                               cr * imag(v00) + sj * real(v11)};
-        arr[i01] = Kokkos::complex<PrecisionT>{cr * real(v01) + sj * imag(v10),
-                                               cr * imag(v01) - sj * real(v10)};
-        arr[i10] = Kokkos::complex<PrecisionT>{cr * real(v10) + sj * imag(v01),
-                                               cr * imag(v10) - sj * real(v01)};
-        arr[i11] = Kokkos::complex<PrecisionT>{cr * real(v11) - sj * imag(v00),
-                                               cr * imag(v11) + sj * real(v00)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct isingZZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    Kokkos::complex<PrecisionT> first;
-    Kokkos::complex<PrecisionT> second;
-    Kokkos::complex<PrecisionT> shift_0;
-    Kokkos::complex<PrecisionT> shift_1;
-
-    isingZZFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        first = Kokkos::complex<PrecisionT>{std::cos(angle / 2),
-                                            -std::sin(angle / 2)};
-        second = Kokkos::complex<PrecisionT>{std::cos(angle / 2),
-                                             std::sin(angle / 2)};
-
-        shift_0 = (inverse) ? conj(first) : first;
-        shift_1 = (inverse) ? conj(second) : second;
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i00] *= shift_0;
-        arr[i01] *= shift_1;
-        arr[i10] *= shift_1;
-        arr[i11] *= shift_0;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct singleExcitationFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-
-    singleExcitationFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                            std::size_t num_qubits,
-                            const std::vector<std::size_t> &wires,
-                            const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-
-        arr[i01] = cr * v01 - sj * v10;
-        arr[i10] = sj * v01 + cr * v10;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct singleExcitationMinusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-    Kokkos::complex<PrecisionT> e;
-
-    singleExcitationMinusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-        e = inverse ? exp(Kokkos::complex<PrecisionT>(0, angle / 2))
-                    : exp(Kokkos::complex<PrecisionT>(0, -angle / 2));
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-
-        arr[i00] *= e;
-        arr[i01] = cr * v01 - sj * v10;
-        arr[i10] = sj * v01 + cr * v10;
-        arr[i11] *= e;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct singleExcitationPlusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT cr;
-    PrecisionT sj;
-    Kokkos::complex<PrecisionT> e;
-
-    singleExcitationPlusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-        e = inverse ? exp(Kokkos::complex<PrecisionT>(0, -angle / 2))
-                    : exp(Kokkos::complex<PrecisionT>(0, angle / 2));
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-
-        arr[i00] *= e;
-        arr[i01] = cr * v01 - sj * v10;
-        arr[i10] = sj * v01 + cr * v10;
-        arr[i11] *= e;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct doubleExcitationFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    PrecisionT cr;
-    PrecisionT sj;
-
-    doubleExcitationFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                            std::size_t num_qubits,
-                            const std::vector<std::size_t> &wires,
-                            const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-
-        const Kokkos::complex<PrecisionT> v3 = arr[i0011];
-        const Kokkos::complex<PrecisionT> v12 = arr[i1100];
-
-        arr[i0011] = cr * v3 - sj * v12;
-        arr[i1100] = sj * v3 + cr * v12;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct doubleExcitationMinusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    PrecisionT cr;
-    PrecisionT sj;
-    Kokkos::complex<PrecisionT> e;
-
-    doubleExcitationMinusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-        e = inverse ? exp(Kokkos::complex<PrecisionT>(0, angle / 2))
-                    : exp(Kokkos::complex<PrecisionT>(0, -angle / 2));
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0001 = i0000 | rev_wire0_shift;
-        const std::size_t i0010 = i0000 | rev_wire1_shift;
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i0100 = i0000 | rev_wire2_shift;
-        const std::size_t i0101 = i0000 | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i0110 = i0000 | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i0111 =
-            i0000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1000 = i0000 | rev_wire3_shift;
-        const std::size_t i1001 = i0000 | rev_wire3_shift | rev_wire0_shift;
-        const std::size_t i1010 = i0000 | rev_wire3_shift | rev_wire1_shift;
-        const std::size_t i1011 =
-            i0000 | rev_wire3_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-        const std::size_t i1101 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i1110 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i1111 = i0000 | rev_wire3_shift | rev_wire2_shift |
-                                  rev_wire1_shift | rev_wire0_shift;
-
-        const Kokkos::complex<PrecisionT> v3 = arr[i0011];
-        const Kokkos::complex<PrecisionT> v12 = arr[i1100];
-
-        arr[i0000] *= e;
-        arr[i0001] *= e;
-        arr[i0010] *= e;
-        arr[i0011] = cr * v3 - sj * v12;
-        arr[i0100] *= e;
-        arr[i0101] *= e;
-        arr[i0110] *= e;
-        arr[i0111] *= e;
-        arr[i1000] *= e;
-        arr[i1001] *= e;
-        arr[i1010] *= e;
-        arr[i1011] *= e;
-        arr[i1100] = sj * v3 + cr * v12;
-        arr[i1101] *= e;
-        arr[i1110] *= e;
-        arr[i1111] *= e;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct doubleExcitationPlusFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire2;
-    std::size_t rev_wire3;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire2_shift;
-    std::size_t rev_wire3_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_min_mid;
-    std::size_t rev_wire_max_mid;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-    std::size_t parity_hmiddle;
-    std::size_t parity_lmiddle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-    Kokkos::complex<PrecisionT> shifts_2;
-    Kokkos::complex<PrecisionT> shifts_3;
-
-    PrecisionT cr;
-    PrecisionT sj;
-    Kokkos::complex<PrecisionT> e;
-
-    doubleExcitationPlusFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[3] - 1;
-        rev_wire1 = num_qubits - wires[2] - 1;
-        rev_wire2 = num_qubits - wires[1] - 1;
-        rev_wire3 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire2_shift = static_cast<std::size_t>(1U) << rev_wire2;
-        rev_wire3_shift = static_cast<std::size_t>(1U) << rev_wire3;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_min_mid = std::max(rev_wire0, rev_wire1);
-        rev_wire_max_mid = std::min(rev_wire2, rev_wire3);
-        rev_wire_max = std::max(rev_wire2, rev_wire3);
-
-        if (rev_wire_max_mid > rev_wire_min_mid) {
-        } else if (rev_wire_max_mid < rev_wire_min) {
-            if (rev_wire_max < rev_wire_min) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-
-                tmp = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min;
-                rev_wire_min = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = rev_wire_min_mid;
-                rev_wire_min_mid = tmp;
-            }
-        } else {
-            if (rev_wire_max > rev_wire_min_mid) {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = tmp;
-            } else {
-                std::size_t tmp = rev_wire_min_mid;
-                rev_wire_min_mid = rev_wire_max_mid;
-                rev_wire_max_mid = rev_wire_max;
-                rev_wire_max = tmp;
-            }
-        }
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_lmiddle = fillLeadingOnes(rev_wire_min + 1) &
-                         fillTrailingOnes(rev_wire_min_mid);
-        parity_hmiddle = fillLeadingOnes(rev_wire_max_mid + 1) &
-                         fillTrailingOnes(rev_wire_max);
-        parity_middle = fillLeadingOnes(rev_wire_min_mid + 1) &
-                        fillTrailingOnes(rev_wire_max_mid);
-
-        cr = std::cos(angle / 2);
-        sj = inverse ? -std::sin(angle / 2) : std::sin(angle / 2);
-        e = inverse ? exp(Kokkos::complex<PrecisionT>(0, -angle / 2))
-                    : exp(Kokkos::complex<PrecisionT>(0, angle / 2));
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0000 =
-            ((k << 4U) & parity_high) | ((k << 3U) & parity_hmiddle) |
-            ((k << 2U) & parity_middle) | ((k << 1U) & parity_lmiddle) |
-            (k & parity_low);
-        const std::size_t i0001 = i0000 | rev_wire0_shift;
-        const std::size_t i0010 = i0000 | rev_wire1_shift;
-        const std::size_t i0011 = i0000 | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i0100 = i0000 | rev_wire2_shift;
-        const std::size_t i0101 = i0000 | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i0110 = i0000 | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i0111 =
-            i0000 | rev_wire2_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1000 = i0000 | rev_wire3_shift;
-        const std::size_t i1001 = i0000 | rev_wire3_shift | rev_wire0_shift;
-        const std::size_t i1010 = i0000 | rev_wire3_shift | rev_wire1_shift;
-        const std::size_t i1011 =
-            i0000 | rev_wire3_shift | rev_wire1_shift | rev_wire0_shift;
-        const std::size_t i1100 = i0000 | rev_wire3_shift | rev_wire2_shift;
-        const std::size_t i1101 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire0_shift;
-        const std::size_t i1110 =
-            i0000 | rev_wire3_shift | rev_wire2_shift | rev_wire1_shift;
-        const std::size_t i1111 = i0000 | rev_wire3_shift | rev_wire2_shift |
-                                  rev_wire1_shift | rev_wire0_shift;
-
-        const Kokkos::complex<PrecisionT> v3 = arr[i0011];
-        const Kokkos::complex<PrecisionT> v12 = arr[i1100];
-
-        arr[i0000] *= e;
-        arr[i0001] *= e;
-        arr[i0010] *= e;
-        arr[i0011] = cr * v3 - sj * v12;
-        arr[i0100] *= e;
-        arr[i0101] *= e;
-        arr[i0110] *= e;
-        arr[i0111] *= e;
-        arr[i1000] *= e;
-        arr[i1001] *= e;
-        arr[i1010] *= e;
-        arr[i1011] *= e;
-        arr[i1100] = sj * v3 + cr * v12;
-        arr[i1101] *= e;
-        arr[i1110] *= e;
-        arr[i1111] *= e;
-    }
-};
-
-template <class PrecisionT, bool inverse = false>
-struct controlledPhaseShiftFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    Kokkos::complex<PrecisionT> s;
-
-    controlledPhaseShiftFunctor(
-        Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-        std::size_t num_qubits, const std::vector<std::size_t> &wires,
-        const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        s = inverse ? exp(-Kokkos::complex<PrecisionT>(0, angle))
-                    : exp(Kokkos::complex<PrecisionT>(0, angle));
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i11 = i00 | rev_wire1_shift | rev_wire0_shift;
-
-        arr[i11] *= s;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct crxFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT c;
-    PrecisionT js;
-
-    crxFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-               std::size_t num_qubits, const std::vector<std::size_t> &wires,
-               const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        c = std::cos(angle / 2);
-        js = (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr[i10] = Kokkos::complex<PrecisionT>{
-            c * Kokkos::real(v10) + js * Kokkos::imag(v11),
-            c * Kokkos::imag(v10) - js * Kokkos::real(v11)};
-        arr[i11] = Kokkos::complex<PrecisionT>{
-            c * Kokkos::real(v11) + js * Kokkos::imag(v10),
-            c * Kokkos::imag(v11) - js * Kokkos::real(v10)};
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct cryFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    PrecisionT c;
-    PrecisionT s;
-
-    cryFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-               std::size_t num_qubits, const std::vector<std::size_t> &wires,
-               const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        c = std::cos(angle / 2);
-        s = (inverse) ? -std::sin(angle / 2) : std::sin(angle / 2);
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr[i10] = c * v10 - s * v11;
-        arr[i11] = s * v10 + c * v11;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct crzFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    Kokkos::complex<PrecisionT> shifts_0;
-    Kokkos::complex<PrecisionT> shifts_1;
-
-    crzFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-               std::size_t num_qubits, const std::vector<std::size_t> &wires,
-               const std::vector<PrecisionT> &params) {
-        rev_wire0 = num_qubits - wires[1] - 1;
-        rev_wire1 = num_qubits - wires[0] - 1; // Control qubit
-
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-
-        const PrecisionT &angle = params[0];
-
-        const Kokkos::complex<PrecisionT> first = Kokkos::complex<PrecisionT>{
-            std::cos(angle / 2), -std::sin(angle / 2)};
-        const Kokkos::complex<PrecisionT> second = Kokkos::complex<PrecisionT>{
-            std::cos(angle / 2), std::sin(angle / 2)};
-
-        shifts_0 = (inverse) ? conj(first) : first;
-        shifts_1 = (inverse) ? conj(second) : second;
-
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        arr[i10] *= shifts_0;
-        arr[i11] *= shifts_1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct multiRZFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    std::size_t wires_parity;
-
-    Kokkos::complex<PrecisionT> shift_0;
-    Kokkos::complex<PrecisionT> shift_1;
-
-    multiRZFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                   std::size_t num_qubits,
-                   const std::vector<std::size_t> &wires,
-                   const std::vector<PrecisionT> &params) {
-        const PrecisionT &angle = params[0];
-        const Kokkos::complex<PrecisionT> first = Kokkos::complex<PrecisionT>{
-            std::cos(angle / 2), -std::sin(angle / 2)};
-        const Kokkos::complex<PrecisionT> second = Kokkos::complex<PrecisionT>{
-            std::cos(angle / 2), std::sin(angle / 2)};
-
-        shift_0 = (inverse) ? conj(first) : first;
-        shift_1 = (inverse) ? conj(second) : second;
-
-        std::size_t wires_parity_ = 0U;
-        for (size_t wire : wires) {
-            wires_parity_ |=
-                (static_cast<std::size_t>(1U) << (num_qubits - wire - 1));
-        }
-
-        wires_parity = wires_parity_;
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        arr[k] *= (Kokkos::Impl::bit_count(k & wires_parity) % 2 == 0)
-                      ? shift_0
-                      : shift_1;
-    }
-};
-
-template <class PrecisionT, bool inverse = false> struct globalPhaseFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-    Kokkos::complex<PrecisionT> phase;
-
-    globalPhaseFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-                       [[maybe_unused]] std::size_t num_qubits,
-                       [[maybe_unused]] const std::vector<std::size_t> &wires,
-                       const std::vector<PrecisionT> &params) {
-        phase = Kokkos::exp(
-            Kokkos::complex<PrecisionT>{0, (inverse) ? params[0] : -params[0]});
-        arr = arr_;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const { arr[k] *= phase; }
-};
-
-template <class PrecisionT, bool inverse = false> struct rotFunctor {
-    Kokkos::View<Kokkos::complex<PrecisionT> *> arr;
-
-    Kokkos::complex<PrecisionT> rot_mat_0b00;
-    Kokkos::complex<PrecisionT> rot_mat_0b10;
-    Kokkos::complex<PrecisionT> rot_mat_0b01;
-    Kokkos::complex<PrecisionT> rot_mat_0b11;
-
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    rotFunctor(Kokkos::View<Kokkos::complex<PrecisionT> *> &arr_,
-               std::size_t num_qubits, const std::vector<std::size_t> &wires,
-               const std::vector<PrecisionT> &params) {
-        const PrecisionT phi = (inverse) ? -params[2] : params[0];
-        const PrecisionT theta = (inverse) ? -params[1] : params[1];
-        const PrecisionT omega = (inverse) ? -params[0] : params[2];
-        const PrecisionT c = std::cos(theta / 2);
-        const PrecisionT s = std::sin(theta / 2);
-        const PrecisionT p{phi + omega};
-        const PrecisionT m{phi - omega};
-
-        auto imag = Kokkos::complex<PrecisionT>(0, 1);
-        rot_mat_0b00 =
-            Kokkos::exp(static_cast<PrecisionT>(p / 2) * (-imag)) * c;
-        rot_mat_0b01 = -Kokkos::exp(static_cast<PrecisionT>(m / 2) * imag) * s;
-        rot_mat_0b10 =
-            Kokkos::exp(static_cast<PrecisionT>(m / 2) * (-imag)) * s;
-        rot_mat_0b11 = Kokkos::exp(static_cast<PrecisionT>(p / 2) * imag) * c;
-
-        arr = arr_;
-        rev_wire = num_qubits - wires[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        const Kokkos::complex<PrecisionT> v0 = arr[i0];
-        const Kokkos::complex<PrecisionT> v1 = arr[i1];
-        arr[i0] = rot_mat_0b00 * v0 +
-                  rot_mat_0b01 * v1; // NOLINT(readability-magic-numbers)
-        arr[i1] = rot_mat_0b10 * v0 +
-                  rot_mat_0b11 * v1; // NOLINT(readability-magic-numbers)
-    }
-};
-
-template <class PrecisionT> struct apply1QubitOpFunctor {
-    using ComplexT = Kokkos::complex<PrecisionT>;
-    using KokkosComplexVector = Kokkos::View<ComplexT *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    const std::size_t n_wires = 1;
-    const std::size_t dim = one << n_wires;
-    std::size_t num_qubits;
-    std::size_t rev_wire;
-    std::size_t rev_wire_shift;
-    std::size_t wire_parity;
-    std::size_t wire_parity_inv;
-
-    apply1QubitOpFunctor(
-        KokkosComplexVector &arr_, std::size_t num_qubits_,
-        const KokkosComplexVector &matrix_,
-        [[maybe_unused]] const std::vector<std::size_t> &wires_) {
-        arr = arr_;
-        matrix = matrix_;
-        num_qubits = num_qubits_;
-
-        rev_wire = num_qubits - wires_[0] - 1;
-        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
-        wire_parity = fillTrailingOnes(rev_wire);
-        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i0 =
-            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
-        const std::size_t i1 = i0 | rev_wire_shift;
-        const Kokkos::complex<PrecisionT> v0 = arr[i0];
-        const Kokkos::complex<PrecisionT> v1 = arr[i1];
-
-        arr(i0) = matrix(0B00) * v0 + matrix(0B01) * v1;
-        arr(i1) = matrix(0B10) * v0 + matrix(0B11) * v1;
-    }
-};
-
-template <class PrecisionT> struct apply2QubitOpFunctor {
-    using ComplexT = Kokkos::complex<PrecisionT>;
-    using KokkosComplexVector = Kokkos::View<ComplexT *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    const std::size_t n_wires = 2;
-    const std::size_t dim = one << n_wires;
-    std::size_t num_qubits;
-    std::size_t rev_wire0;
-    std::size_t rev_wire1;
-    std::size_t rev_wire0_shift;
-    std::size_t rev_wire1_shift;
-    std::size_t rev_wire_min;
-    std::size_t rev_wire_max;
-    std::size_t parity_low;
-    std::size_t parity_high;
-    std::size_t parity_middle;
-
-    apply2QubitOpFunctor(
-        KokkosComplexVector &arr_, std::size_t num_qubits_,
-        const KokkosComplexVector &matrix_,
-        [[maybe_unused]] const std::vector<std::size_t> &wires_) {
-        arr = arr_;
-        matrix = matrix_;
-        num_qubits = num_qubits_;
-
-        rev_wire0 = num_qubits - wires_[1] - 1;
-        rev_wire1 = num_qubits - wires_[0] - 1; // Control qubit
-        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
-        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
-        rev_wire_min = std::min(rev_wire0, rev_wire1);
-        rev_wire_max = std::max(rev_wire0, rev_wire1);
-        parity_low = fillTrailingOnes(rev_wire_min);
-        parity_high = fillLeadingOnes(rev_wire_max + 1);
-        parity_middle =
-            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        const std::size_t i00 = ((k << 2U) & parity_high) |
-                                ((k << 1U) & parity_middle) | (k & parity_low);
-        const std::size_t i10 = i00 | rev_wire1_shift;
-        const std::size_t i01 = i00 | rev_wire0_shift;
-        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
-
-        const Kokkos::complex<PrecisionT> v00 = arr[i00];
-        const Kokkos::complex<PrecisionT> v01 = arr[i01];
-        const Kokkos::complex<PrecisionT> v10 = arr[i10];
-        const Kokkos::complex<PrecisionT> v11 = arr[i11];
-
-        arr(i00) = matrix(0B0000) * v00 + matrix(0B0001) * v01 +
-                   matrix(0B0010) * v10 + matrix(0B0011) * v11;
-        arr(i01) = matrix(0B0100) * v00 + matrix(0B0101) * v01 +
-                   matrix(0B0110) * v10 + matrix(0B0111) * v11;
-        arr(i10) = matrix(0B1000) * v00 + matrix(0B1001) * v01 +
-                   matrix(0B1010) * v10 + matrix(0B1011) * v11;
-        arr(i11) = matrix(0B1100) * v00 + matrix(0B1101) * v01 +
-                   matrix(0B1110) * v10 + matrix(0B1111) * v11;
-    }
-};
-
-#define GATEENTRY3(xx, yy) xx << 3 | yy
-#define GATETERM3(xx, yy, vyy) matrix(GATEENTRY3(xx, yy)) * vyy
-#define GATESUM3(xx)                                                           \
-    GATETERM3(xx, 0B000, v000) + GATETERM3(xx, 0B001, v001) +                  \
-        GATETERM3(xx, 0B010, v010) + GATETERM3(xx, 0B011, v011) +              \
-        GATETERM3(xx, 0B100, v100) + GATETERM3(xx, 0B101, v101) +              \
-        GATETERM3(xx, 0B110, v110) + GATETERM3(xx, 0B111, v111)
-
-template <class PrecisionT> struct apply3QubitOpFunctor {
-    using ComplexT = Kokkos::complex<PrecisionT>;
-    using KokkosComplexVector = Kokkos::View<ComplexT *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    KokkosIntVector wires;
-    KokkosIntVector parity;
-    KokkosIntVector rev_wire_shifts;
-    const std::size_t n_wires = 3;
-    const std::size_t dim = one << n_wires;
-    std::size_t num_qubits;
-
-    apply3QubitOpFunctor(KokkosComplexVector &arr_, std::size_t num_qubits_,
-                         const KokkosComplexVector &matrix_,
-                         const std::vector<std::size_t> &wires_) {
-        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-            wires_host(wires_.data(), wires_.size());
-        Kokkos::resize(wires, wires_host.size());
-        Kokkos::deep_copy(wires, wires_host);
-        arr = arr_;
-        matrix = matrix_;
-        num_qubits = num_qubits_;
-        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        std::size_t i000 = (k & parity(0));
-        for (std::size_t i = 1; i < parity.size(); i++) {
-            i000 |= ((k << i) & parity(i));
-        }
-        ComplexT v000 = arr(i000);
-
-        std::size_t i001 = i000 | rev_wire_shifts(0);
-        ComplexT v001 = arr(i001);
-        std::size_t i010 = i000 | rev_wire_shifts(1);
-        ComplexT v010 = arr(i010);
-        std::size_t i011 = i000 | rev_wire_shifts(0) | rev_wire_shifts(1);
-        ComplexT v011 = arr(i011);
-        std::size_t i100 = i000 | rev_wire_shifts(2);
-        ComplexT v100 = arr(i100);
-        std::size_t i101 = i000 | rev_wire_shifts(0) | rev_wire_shifts(2);
-        ComplexT v101 = arr(i101);
-        std::size_t i110 = i000 | rev_wire_shifts(1) | rev_wire_shifts(2);
-        ComplexT v110 = arr(i110);
-        std::size_t i111 =
-            i000 | rev_wire_shifts(0) | rev_wire_shifts(1) | rev_wire_shifts(2);
-        ComplexT v111 = arr(i111);
-        arr(i000) = GATESUM3(0B000);
-        arr(i001) = GATESUM3(0B001);
-        arr(i010) = GATESUM3(0B010);
-        arr(i011) = GATESUM3(0B011);
-        arr(i100) = GATESUM3(0B100);
-        arr(i101) = GATESUM3(0B101);
-        arr(i110) = GATESUM3(0B110);
-        arr(i111) = GATESUM3(0B111);
-    }
-};
-
-#define GATEENTRY4(xx, yy) xx << 4 | yy
-#define GATETERM4(xx, yy, vyy) matrix(GATEENTRY4(xx, yy)) * vyy
-#define GATESUM4(xx)                                                           \
-    GATETERM4(xx, 0B0000, v0000) + GATETERM4(xx, 0B0001, v0001) +              \
-        GATETERM4(xx, 0B0010, v0010) + GATETERM4(xx, 0B0011, v0011) +          \
-        GATETERM4(xx, 0B0100, v0100) + GATETERM4(xx, 0B0101, v0101) +          \
-        GATETERM4(xx, 0B0110, v0110) + GATETERM4(xx, 0B0111, v0111) +          \
-        GATETERM4(xx, 0B1000, v1000) + GATETERM4(xx, 0B1001, v1001) +          \
-        GATETERM4(xx, 0B1010, v1010) + GATETERM4(xx, 0B1011, v1011) +          \
-        GATETERM4(xx, 0B1100, v1100) + GATETERM4(xx, 0B1101, v1101) +          \
-        GATETERM4(xx, 0B1110, v1110) + GATETERM4(xx, 0B1111, v1111)
-
-template <class PrecisionT> struct apply4QubitOpFunctor {
-    using ComplexT = Kokkos::complex<PrecisionT>;
-    using KokkosComplexVector = Kokkos::View<ComplexT *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    KokkosIntVector wires;
-    KokkosIntVector parity;
-    KokkosIntVector rev_wire_shifts;
-    const std::size_t n_wires = 4;
-    const std::size_t dim = one << n_wires;
-    std::size_t num_qubits;
-
-    apply4QubitOpFunctor(KokkosComplexVector &arr_, std::size_t num_qubits_,
-                         const KokkosComplexVector &matrix_,
-                         const std::vector<std::size_t> &wires_) {
-        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-            wires_host(wires_.data(), wires_.size());
-        Kokkos::resize(wires, wires_host.size());
-        Kokkos::deep_copy(wires, wires_host);
-        arr = arr_;
-        matrix = matrix_;
-        num_qubits = num_qubits_;
-        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        std::size_t i0000 = (k & parity(0));
-        for (std::size_t i = 1; i < parity.size(); i++) {
-            i0000 |= ((k << i) & parity(i));
-        }
-        ComplexT v0000 = arr(i0000);
-
-        std::size_t i0001 = i0000 | rev_wire_shifts(0);
-        ComplexT v0001 = arr(i0001);
-        std::size_t i0010 = i0000 | rev_wire_shifts(1);
-        ComplexT v0010 = arr(i0010);
-        std::size_t i0011 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1);
-        ComplexT v0011 = arr(i0011);
-        std::size_t i0100 = i0000 | rev_wire_shifts(2);
-        ComplexT v0100 = arr(i0100);
-        std::size_t i0101 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(2);
-        ComplexT v0101 = arr(i0101);
-        std::size_t i0110 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(2);
-        ComplexT v0110 = arr(i0110);
-        std::size_t i0111 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                            rev_wire_shifts(2);
-        ComplexT v0111 = arr(i0111);
-        std::size_t i1000 = i0000 | rev_wire_shifts(3);
-        ComplexT v1000 = arr(i1000);
-        std::size_t i1001 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(3);
-        ComplexT v1001 = arr(i1001);
-        std::size_t i1010 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(3);
-        ComplexT v1010 = arr(i1010);
-        std::size_t i1011 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                            rev_wire_shifts(3);
-        ComplexT v1011 = arr(i1011);
-        std::size_t i1100 = i0000 | rev_wire_shifts(2) | rev_wire_shifts(3);
-        ComplexT v1100 = arr(i1100);
-        std::size_t i1101 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
-                            rev_wire_shifts(3);
-        ComplexT v1101 = arr(i1101);
-        std::size_t i1110 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
-                            rev_wire_shifts(3);
-        ComplexT v1110 = arr(i1110);
-        std::size_t i1111 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                            rev_wire_shifts(2) | rev_wire_shifts(3);
-        ComplexT v1111 = arr(i1111);
-
-        arr(i0000) = GATESUM4(0B0000);
-        arr(i0001) = GATESUM4(0B0001);
-        arr(i0010) = GATESUM4(0B0010);
-        arr(i0011) = GATESUM4(0B0011);
-        arr(i0100) = GATESUM4(0B0100);
-        arr(i0101) = GATESUM4(0B0101);
-        arr(i0110) = GATESUM4(0B0110);
-        arr(i0111) = GATESUM4(0B0111);
-        arr(i1000) = GATESUM4(0B1000);
-        arr(i1001) = GATESUM4(0B1001);
-        arr(i1010) = GATESUM4(0B1010);
-        arr(i1011) = GATESUM4(0B1011);
-        arr(i1100) = GATESUM4(0B1100);
-        arr(i1101) = GATESUM4(0B1101);
-        arr(i1110) = GATESUM4(0B1110);
-        arr(i1111) = GATESUM4(0B1111);
-    }
-};
-
-#define GATEENTRY5(xx, yy) xx << 5 | yy
-#define GATETERM5(xx, yy, vyy) matrix(GATEENTRY5(xx, yy)) * vyy
-#define GATESUM5(xx)                                                           \
-    GATETERM5(xx, 0B00000, v00000) + GATETERM5(xx, 0B00001, v00001) +          \
-        GATETERM5(xx, 0B00010, v00010) + GATETERM5(xx, 0B00011, v00011) +      \
-        GATETERM5(xx, 0B00100, v00100) + GATETERM5(xx, 0B00101, v00101) +      \
-        GATETERM5(xx, 0B00110, v00110) + GATETERM5(xx, 0B00111, v00111) +      \
-        GATETERM5(xx, 0B01000, v01000) + GATETERM5(xx, 0B01001, v01001) +      \
-        GATETERM5(xx, 0B01010, v01010) + GATETERM5(xx, 0B01011, v01011) +      \
-        GATETERM5(xx, 0B01100, v01100) + GATETERM5(xx, 0B01101, v01101) +      \
-        GATETERM5(xx, 0B01110, v01110) + GATETERM5(xx, 0B01111, v01111) +      \
-        GATETERM5(xx, 0B10000, v10000) + GATETERM5(xx, 0B10001, v10001) +      \
-        GATETERM5(xx, 0B10010, v10010) + GATETERM5(xx, 0B10011, v10011) +      \
-        GATETERM5(xx, 0B10100, v10100) + GATETERM5(xx, 0B10101, v10101) +      \
-        GATETERM5(xx, 0B10110, v10110) + GATETERM5(xx, 0B10111, v10111) +      \
-        GATETERM5(xx, 0B11000, v11000) + GATETERM5(xx, 0B11001, v11001) +      \
-        GATETERM5(xx, 0B11010, v11010) + GATETERM5(xx, 0B11011, v11011) +      \
-        GATETERM5(xx, 0B11100, v11100) + GATETERM5(xx, 0B11101, v11101) +      \
-        GATETERM5(xx, 0B11110, v11110) + GATETERM5(xx, 0B11111, v11111)
-template <class PrecisionT> struct apply5QubitOpFunctor {
-    using ComplexT = Kokkos::complex<PrecisionT>;
-    using KokkosComplexVector = Kokkos::View<ComplexT *>;
-    using KokkosIntVector = Kokkos::View<std::size_t *>;
-
-    KokkosComplexVector arr;
-    KokkosComplexVector matrix;
-    KokkosIntVector wires;
-    KokkosIntVector parity;
-    KokkosIntVector rev_wire_shifts;
-    const std::size_t n_wires = 5;
-    const std::size_t dim = one << n_wires;
-    std::size_t num_qubits;
-
-    apply5QubitOpFunctor(KokkosComplexVector &arr_, std::size_t num_qubits_,
-                         const KokkosComplexVector &matrix_,
-                         const std::vector<std::size_t> &wires_) {
-        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
-                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-            wires_host(wires_.data(), wires_.size());
-        Kokkos::resize(wires, wires_host.size());
-        Kokkos::deep_copy(wires, wires_host);
-        arr = arr_;
-        matrix = matrix_;
-        num_qubits = num_qubits_;
-        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const std::size_t k) const {
-        std::size_t i00000 = (k & parity(0));
-        for (std::size_t i = 1; i < parity.size(); i++) {
-            i00000 |= ((k << i) & parity(i));
-        }
-        ComplexT v00000 = arr(i00000);
-
-        std::size_t i00001 = i00000 | rev_wire_shifts(0);
-        ComplexT v00001 = arr(i00001);
-        std::size_t i00010 = i00000 | rev_wire_shifts(1);
-        ComplexT v00010 = arr(i00010);
-        std::size_t i00011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1);
-        ComplexT v00011 = arr(i00011);
-        std::size_t i00100 = i00000 | rev_wire_shifts(2);
-        ComplexT v00100 = arr(i00100);
-        std::size_t i00101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2);
-        ComplexT v00101 = arr(i00101);
-        std::size_t i00110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2);
-        ComplexT v00110 = arr(i00110);
-        std::size_t i00111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(2);
-        ComplexT v00111 = arr(i00111);
-        std::size_t i01000 = i00000 | rev_wire_shifts(3);
-        ComplexT v01000 = arr(i01000);
-        std::size_t i01001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(3);
-        ComplexT v01001 = arr(i01001);
-        std::size_t i01010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(3);
-        ComplexT v01010 = arr(i01010);
-        std::size_t i01011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(3);
-        ComplexT v01011 = arr(i01011);
-        std::size_t i01100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(3);
-        ComplexT v01100 = arr(i01100);
-        std::size_t i01101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
-                             rev_wire_shifts(3);
-        ComplexT v01101 = arr(i01101);
-        std::size_t i01110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
-                             rev_wire_shifts(3);
-        ComplexT v01110 = arr(i01110);
-        std::size_t i01111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(2) | rev_wire_shifts(3);
-        ComplexT v01111 = arr(i01111);
-        std::size_t i10000 = i00000 | rev_wire_shifts(4);
-        ComplexT v10000 = arr(i10000);
-        std::size_t i10001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(4);
-        ComplexT v10001 = arr(i10001);
-        std::size_t i10010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(4);
-        ComplexT v10010 = arr(i10010);
-        std::size_t i10011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(4);
-        ComplexT v10011 = arr(i10011);
-        std::size_t i10100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(4);
-        ComplexT v10100 = arr(i10100);
-        std::size_t i10101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
-                             rev_wire_shifts(4);
-        ComplexT v10101 = arr(i10101);
-        std::size_t i10110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
-                             rev_wire_shifts(4);
-        ComplexT v10110 = arr(i10110);
-        std::size_t i10111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(2) | rev_wire_shifts(4);
-        ComplexT v10111 = arr(i10111);
-        std::size_t i11000 = i00000 | rev_wire_shifts(3) | rev_wire_shifts(4);
-        ComplexT v11000 = arr(i11000);
-        std::size_t i11001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(3) |
-                             rev_wire_shifts(4);
-        ComplexT v11001 = arr(i11001);
-        std::size_t i11010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(3) |
-                             rev_wire_shifts(4);
-        ComplexT v11010 = arr(i11010);
-        std::size_t i11011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(3) | rev_wire_shifts(4);
-        ComplexT v11011 = arr(i11011);
-        std::size_t i11100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(3) |
-                             rev_wire_shifts(4);
-        ComplexT v11100 = arr(i11100);
-        std::size_t i11101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
-                             rev_wire_shifts(3) | rev_wire_shifts(4);
-        ComplexT v11101 = arr(i11101);
-        std::size_t i11110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
-                             rev_wire_shifts(3) | rev_wire_shifts(4);
-        ComplexT v11110 = arr(i11110);
-        std::size_t i11111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
-                             rev_wire_shifts(2) | rev_wire_shifts(3) |
-                             rev_wire_shifts(4);
-        ComplexT v11111 = arr(i11111);
-
-        arr(i00000) = GATESUM5(0B00000);
-        arr(i00001) = GATESUM5(0B00001);
-        arr(i00010) = GATESUM5(0B00010);
-        arr(i00011) = GATESUM5(0B00011);
-        arr(i00100) = GATESUM5(0B00100);
-        arr(i00101) = GATESUM5(0B00101);
-        arr(i00110) = GATESUM5(0B00110);
-        arr(i00111) = GATESUM5(0B00111);
-        arr(i01000) = GATESUM5(0B01000);
-        arr(i01001) = GATESUM5(0B01001);
-        arr(i01010) = GATESUM5(0B01010);
-        arr(i01011) = GATESUM5(0B01011);
-        arr(i01100) = GATESUM5(0B01100);
-        arr(i01101) = GATESUM5(0B01101);
-        arr(i01110) = GATESUM5(0B01110);
-        arr(i01111) = GATESUM5(0B01111);
-        arr(i10000) = GATESUM5(0B10000);
-        arr(i10001) = GATESUM5(0B10001);
-        arr(i10010) = GATESUM5(0B10010);
-        arr(i10011) = GATESUM5(0B10011);
-        arr(i10100) = GATESUM5(0B10100);
-        arr(i10101) = GATESUM5(0B10101);
-        arr(i10110) = GATESUM5(0B10110);
-        arr(i10111) = GATESUM5(0B10111);
-        arr(i11000) = GATESUM5(0B11000);
-        arr(i11001) = GATESUM5(0B11001);
-        arr(i11010) = GATESUM5(0B11010);
-        arr(i11011) = GATESUM5(0B11011);
-        arr(i11100) = GATESUM5(0B11100);
-        arr(i11101) = GATESUM5(0B11101);
-        arr(i11110) = GATESUM5(0B11110);
-        arr(i11111) = GATESUM5(0B11111);
-    }
-};
-
-} // namespace Pennylane::LightningKokkos::Functors
\ No newline at end of file
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/MatrixGateFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/MatrixGateFunctors.hpp
new file mode 100644
index 0000000000..065c63244f
--- /dev/null
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/MatrixGateFunctors.hpp
@@ -0,0 +1,559 @@
+// Copyright 2018-2024 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an AS IS BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_StdAlgorithms.hpp>
+
+#include "BitUtil.hpp"
+#include "BitUtilKokkos.hpp"
+
+/// @cond DEV
+namespace {
+using namespace Pennylane::Util;
+using Kokkos::Experimental::swap;
+using Pennylane::LightningKokkos::Util::one;
+using Pennylane::LightningKokkos::Util::wires2Parity;
+using std::size_t;
+} // namespace
+/// @endcond
+
+namespace Pennylane::LightningKokkos::Functors {
+
+template <class Precision> struct multiQubitOpFunctor {
+    using KokkosComplexVector = Kokkos::View<Kokkos::complex<Precision> *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+    using ScratchViewComplex =
+        Kokkos::View<Kokkos::complex<Precision> *,
+                     Kokkos::DefaultExecutionSpace::scratch_memory_space,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
+    using ScratchViewSizeT =
+        Kokkos::View<std::size_t *,
+                     Kokkos::DefaultExecutionSpace::scratch_memory_space,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
+    using MemberType = Kokkos::TeamPolicy<>::member_type;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    KokkosIntVector wires;
+    KokkosIntVector parity;
+    KokkosIntVector rev_wire_shifts;
+    std::size_t dim;
+    std::size_t num_qubits;
+
+    multiQubitOpFunctor(KokkosComplexVector arr_, std::size_t num_qubits_,
+                        const KokkosComplexVector &matrix_,
+                        const std::vector<std::size_t> &wires_) {
+        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+            wires_host(wires_.data(), wires_.size());
+        Kokkos::resize(wires, wires_host.size());
+        Kokkos::deep_copy(wires, wires_host);
+        dim = one << wires_.size();
+        num_qubits = num_qubits_;
+        arr = arr_;
+        matrix = matrix_;
+        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const MemberType &teamMember) const {
+        const std::size_t k = teamMember.league_rank();
+        ScratchViewComplex coeffs_in(teamMember.team_scratch(0), dim);
+        ScratchViewSizeT indices(teamMember.team_scratch(0), dim);
+        if (teamMember.team_rank() == 0) {
+            std::size_t idx = (k & parity(0));
+            for (std::size_t i = 1; i < parity.size(); i++) {
+                idx |= ((k << i) & parity(i));
+            }
+            indices(0) = idx;
+            coeffs_in(0) = arr(idx);
+
+            Kokkos::parallel_for(Kokkos::ThreadVectorRange(teamMember, 1, dim),
+                                 [&](const std::size_t inner_idx) {
+                                     std::size_t index = indices(0);
+                                     for (std::size_t i = 0; i < wires.size();
+                                          i++) {
+                                         if ((inner_idx & (one << i)) != 0) {
+                                             index |= rev_wire_shifts(i);
+                                         }
+                                     }
+                                     indices(inner_idx) = index;
+                                     coeffs_in(inner_idx) = arr(index);
+                                 });
+        }
+        teamMember.team_barrier();
+        Kokkos::parallel_for(
+            Kokkos::TeamThreadRange(teamMember, dim), [&](const std::size_t i) {
+                const auto idx = indices(i);
+                arr(idx) = 0.0;
+                const std::size_t base_idx = i * dim;
+
+                for (std::size_t j = 0; j < dim; j++) {
+                    arr(idx) += matrix(base_idx + j) * coeffs_in(j);
+                }
+            });
+    }
+};
+
+template <class PrecisionT> struct apply1QubitOpFunctor {
+    using ComplexT = Kokkos::complex<PrecisionT>;
+    using KokkosComplexVector = Kokkos::View<ComplexT *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    const std::size_t n_wires = 1;
+    const std::size_t dim = one << n_wires;
+    std::size_t num_qubits;
+    std::size_t rev_wire;
+    std::size_t rev_wire_shift;
+    std::size_t wire_parity;
+    std::size_t wire_parity_inv;
+
+    apply1QubitOpFunctor(
+        KokkosComplexVector arr_, std::size_t num_qubits_,
+        const KokkosComplexVector &matrix_,
+        [[maybe_unused]] const std::vector<std::size_t> &wires_) {
+        arr = arr_;
+        matrix = matrix_;
+        num_qubits = num_qubits_;
+
+        rev_wire = num_qubits - wires_[0] - 1;
+        rev_wire_shift = (static_cast<std::size_t>(1U) << rev_wire);
+        wire_parity = fillTrailingOnes(rev_wire);
+        wire_parity_inv = fillLeadingOnes(rev_wire + 1);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const std::size_t k) const {
+        const std::size_t i0 =
+            ((k << 1U) & wire_parity_inv) | (wire_parity & k);
+        const std::size_t i1 = i0 | rev_wire_shift;
+        const Kokkos::complex<PrecisionT> v0 = arr[i0];
+        const Kokkos::complex<PrecisionT> v1 = arr[i1];
+
+        arr(i0) = matrix(0B00) * v0 + matrix(0B01) * v1;
+        arr(i1) = matrix(0B10) * v0 + matrix(0B11) * v1;
+    }
+};
+
+template <class PrecisionT> struct apply2QubitOpFunctor {
+    using ComplexT = Kokkos::complex<PrecisionT>;
+    using KokkosComplexVector = Kokkos::View<ComplexT *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    const std::size_t n_wires = 2;
+    const std::size_t dim = one << n_wires;
+    std::size_t num_qubits;
+    std::size_t rev_wire0;
+    std::size_t rev_wire1;
+    std::size_t rev_wire0_shift;
+    std::size_t rev_wire1_shift;
+    std::size_t rev_wire_min;
+    std::size_t rev_wire_max;
+    std::size_t parity_low;
+    std::size_t parity_high;
+    std::size_t parity_middle;
+
+    apply2QubitOpFunctor(
+        KokkosComplexVector arr_, std::size_t num_qubits_,
+        const KokkosComplexVector &matrix_,
+        [[maybe_unused]] const std::vector<std::size_t> &wires_) {
+        arr = arr_;
+        matrix = matrix_;
+        num_qubits = num_qubits_;
+
+        rev_wire0 = num_qubits - wires_[1] - 1;
+        rev_wire1 = num_qubits - wires_[0] - 1; // Control qubit
+        rev_wire0_shift = static_cast<std::size_t>(1U) << rev_wire0;
+        rev_wire1_shift = static_cast<std::size_t>(1U) << rev_wire1;
+        rev_wire_min = std::min(rev_wire0, rev_wire1);
+        rev_wire_max = std::max(rev_wire0, rev_wire1);
+        parity_low = fillTrailingOnes(rev_wire_min);
+        parity_high = fillLeadingOnes(rev_wire_max + 1);
+        parity_middle =
+            fillLeadingOnes(rev_wire_min + 1) & fillTrailingOnes(rev_wire_max);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const std::size_t k) const {
+        const std::size_t i00 = ((k << 2U) & parity_high) |
+                                ((k << 1U) & parity_middle) | (k & parity_low);
+        const std::size_t i10 = i00 | rev_wire1_shift;
+        const std::size_t i01 = i00 | rev_wire0_shift;
+        const std::size_t i11 = i00 | rev_wire0_shift | rev_wire1_shift;
+
+        const Kokkos::complex<PrecisionT> v00 = arr[i00];
+        const Kokkos::complex<PrecisionT> v01 = arr[i01];
+        const Kokkos::complex<PrecisionT> v10 = arr[i10];
+        const Kokkos::complex<PrecisionT> v11 = arr[i11];
+
+        arr(i00) = matrix(0B0000) * v00 + matrix(0B0001) * v01 +
+                   matrix(0B0010) * v10 + matrix(0B0011) * v11;
+        arr(i01) = matrix(0B0100) * v00 + matrix(0B0101) * v01 +
+                   matrix(0B0110) * v10 + matrix(0B0111) * v11;
+        arr(i10) = matrix(0B1000) * v00 + matrix(0B1001) * v01 +
+                   matrix(0B1010) * v10 + matrix(0B1011) * v11;
+        arr(i11) = matrix(0B1100) * v00 + matrix(0B1101) * v01 +
+                   matrix(0B1110) * v10 + matrix(0B1111) * v11;
+    }
+};
+
+#define GATEENTRY3(xx, yy) xx << 3 | yy
+#define GATETERM3(xx, yy, vyy) matrix(GATEENTRY3(xx, yy)) * vyy
+#define GATESUM3(xx)                                                           \
+    GATETERM3(xx, 0B000, v000) + GATETERM3(xx, 0B001, v001) +                  \
+        GATETERM3(xx, 0B010, v010) + GATETERM3(xx, 0B011, v011) +              \
+        GATETERM3(xx, 0B100, v100) + GATETERM3(xx, 0B101, v101) +              \
+        GATETERM3(xx, 0B110, v110) + GATETERM3(xx, 0B111, v111)
+
+template <class PrecisionT> struct apply3QubitOpFunctor {
+    using ComplexT = Kokkos::complex<PrecisionT>;
+    using KokkosComplexVector = Kokkos::View<ComplexT *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    KokkosIntVector wires;
+    KokkosIntVector parity;
+    KokkosIntVector rev_wire_shifts;
+    const std::size_t n_wires = 3;
+    const std::size_t dim = one << n_wires;
+    std::size_t num_qubits;
+
+    apply3QubitOpFunctor(KokkosComplexVector arr_, std::size_t num_qubits_,
+                         const KokkosComplexVector &matrix_,
+                         const std::vector<std::size_t> &wires_) {
+        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+            wires_host(wires_.data(), wires_.size());
+        Kokkos::resize(wires, wires_host.size());
+        Kokkos::deep_copy(wires, wires_host);
+        arr = arr_;
+        matrix = matrix_;
+        num_qubits = num_qubits_;
+        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const std::size_t k) const {
+        std::size_t i000 = (k & parity(0));
+        for (std::size_t i = 1; i < parity.size(); i++) {
+            i000 |= ((k << i) & parity(i));
+        }
+        ComplexT v000 = arr(i000);
+
+        std::size_t i001 = i000 | rev_wire_shifts(0);
+        ComplexT v001 = arr(i001);
+        std::size_t i010 = i000 | rev_wire_shifts(1);
+        ComplexT v010 = arr(i010);
+        std::size_t i011 = i000 | rev_wire_shifts(0) | rev_wire_shifts(1);
+        ComplexT v011 = arr(i011);
+        std::size_t i100 = i000 | rev_wire_shifts(2);
+        ComplexT v100 = arr(i100);
+        std::size_t i101 = i000 | rev_wire_shifts(0) | rev_wire_shifts(2);
+        ComplexT v101 = arr(i101);
+        std::size_t i110 = i000 | rev_wire_shifts(1) | rev_wire_shifts(2);
+        ComplexT v110 = arr(i110);
+        std::size_t i111 =
+            i000 | rev_wire_shifts(0) | rev_wire_shifts(1) | rev_wire_shifts(2);
+        ComplexT v111 = arr(i111);
+        arr(i000) = GATESUM3(0B000);
+        arr(i001) = GATESUM3(0B001);
+        arr(i010) = GATESUM3(0B010);
+        arr(i011) = GATESUM3(0B011);
+        arr(i100) = GATESUM3(0B100);
+        arr(i101) = GATESUM3(0B101);
+        arr(i110) = GATESUM3(0B110);
+        arr(i111) = GATESUM3(0B111);
+    }
+};
+
+#define GATEENTRY4(xx, yy) xx << 4 | yy
+#define GATETERM4(xx, yy, vyy) matrix(GATEENTRY4(xx, yy)) * vyy
+#define GATESUM4(xx)                                                           \
+    GATETERM4(xx, 0B0000, v0000) + GATETERM4(xx, 0B0001, v0001) +              \
+        GATETERM4(xx, 0B0010, v0010) + GATETERM4(xx, 0B0011, v0011) +          \
+        GATETERM4(xx, 0B0100, v0100) + GATETERM4(xx, 0B0101, v0101) +          \
+        GATETERM4(xx, 0B0110, v0110) + GATETERM4(xx, 0B0111, v0111) +          \
+        GATETERM4(xx, 0B1000, v1000) + GATETERM4(xx, 0B1001, v1001) +          \
+        GATETERM4(xx, 0B1010, v1010) + GATETERM4(xx, 0B1011, v1011) +          \
+        GATETERM4(xx, 0B1100, v1100) + GATETERM4(xx, 0B1101, v1101) +          \
+        GATETERM4(xx, 0B1110, v1110) + GATETERM4(xx, 0B1111, v1111)
+
+template <class PrecisionT> struct apply4QubitOpFunctor {
+    using ComplexT = Kokkos::complex<PrecisionT>;
+    using KokkosComplexVector = Kokkos::View<ComplexT *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    KokkosIntVector wires;
+    KokkosIntVector parity;
+    KokkosIntVector rev_wire_shifts;
+    const std::size_t n_wires = 4;
+    const std::size_t dim = one << n_wires;
+    std::size_t num_qubits;
+
+    apply4QubitOpFunctor(KokkosComplexVector arr_, std::size_t num_qubits_,
+                         const KokkosComplexVector &matrix_,
+                         const std::vector<std::size_t> &wires_) {
+        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+            wires_host(wires_.data(), wires_.size());
+        Kokkos::resize(wires, wires_host.size());
+        Kokkos::deep_copy(wires, wires_host);
+        arr = arr_;
+        matrix = matrix_;
+        num_qubits = num_qubits_;
+        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const std::size_t k) const {
+        std::size_t i0000 = (k & parity(0));
+        for (std::size_t i = 1; i < parity.size(); i++) {
+            i0000 |= ((k << i) & parity(i));
+        }
+        ComplexT v0000 = arr(i0000);
+
+        std::size_t i0001 = i0000 | rev_wire_shifts(0);
+        ComplexT v0001 = arr(i0001);
+        std::size_t i0010 = i0000 | rev_wire_shifts(1);
+        ComplexT v0010 = arr(i0010);
+        std::size_t i0011 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1);
+        ComplexT v0011 = arr(i0011);
+        std::size_t i0100 = i0000 | rev_wire_shifts(2);
+        ComplexT v0100 = arr(i0100);
+        std::size_t i0101 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(2);
+        ComplexT v0101 = arr(i0101);
+        std::size_t i0110 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(2);
+        ComplexT v0110 = arr(i0110);
+        std::size_t i0111 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                            rev_wire_shifts(2);
+        ComplexT v0111 = arr(i0111);
+        std::size_t i1000 = i0000 | rev_wire_shifts(3);
+        ComplexT v1000 = arr(i1000);
+        std::size_t i1001 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(3);
+        ComplexT v1001 = arr(i1001);
+        std::size_t i1010 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(3);
+        ComplexT v1010 = arr(i1010);
+        std::size_t i1011 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                            rev_wire_shifts(3);
+        ComplexT v1011 = arr(i1011);
+        std::size_t i1100 = i0000 | rev_wire_shifts(2) | rev_wire_shifts(3);
+        ComplexT v1100 = arr(i1100);
+        std::size_t i1101 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
+                            rev_wire_shifts(3);
+        ComplexT v1101 = arr(i1101);
+        std::size_t i1110 = i0000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
+                            rev_wire_shifts(3);
+        ComplexT v1110 = arr(i1110);
+        std::size_t i1111 = i0000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                            rev_wire_shifts(2) | rev_wire_shifts(3);
+        ComplexT v1111 = arr(i1111);
+
+        arr(i0000) = GATESUM4(0B0000);
+        arr(i0001) = GATESUM4(0B0001);
+        arr(i0010) = GATESUM4(0B0010);
+        arr(i0011) = GATESUM4(0B0011);
+        arr(i0100) = GATESUM4(0B0100);
+        arr(i0101) = GATESUM4(0B0101);
+        arr(i0110) = GATESUM4(0B0110);
+        arr(i0111) = GATESUM4(0B0111);
+        arr(i1000) = GATESUM4(0B1000);
+        arr(i1001) = GATESUM4(0B1001);
+        arr(i1010) = GATESUM4(0B1010);
+        arr(i1011) = GATESUM4(0B1011);
+        arr(i1100) = GATESUM4(0B1100);
+        arr(i1101) = GATESUM4(0B1101);
+        arr(i1110) = GATESUM4(0B1110);
+        arr(i1111) = GATESUM4(0B1111);
+    }
+};
+
+#define GATEENTRY5(xx, yy) xx << 5 | yy
+#define GATETERM5(xx, yy, vyy) matrix(GATEENTRY5(xx, yy)) * vyy
+#define GATESUM5(xx)                                                           \
+    GATETERM5(xx, 0B00000, v00000) + GATETERM5(xx, 0B00001, v00001) +          \
+        GATETERM5(xx, 0B00010, v00010) + GATETERM5(xx, 0B00011, v00011) +      \
+        GATETERM5(xx, 0B00100, v00100) + GATETERM5(xx, 0B00101, v00101) +      \
+        GATETERM5(xx, 0B00110, v00110) + GATETERM5(xx, 0B00111, v00111) +      \
+        GATETERM5(xx, 0B01000, v01000) + GATETERM5(xx, 0B01001, v01001) +      \
+        GATETERM5(xx, 0B01010, v01010) + GATETERM5(xx, 0B01011, v01011) +      \
+        GATETERM5(xx, 0B01100, v01100) + GATETERM5(xx, 0B01101, v01101) +      \
+        GATETERM5(xx, 0B01110, v01110) + GATETERM5(xx, 0B01111, v01111) +      \
+        GATETERM5(xx, 0B10000, v10000) + GATETERM5(xx, 0B10001, v10001) +      \
+        GATETERM5(xx, 0B10010, v10010) + GATETERM5(xx, 0B10011, v10011) +      \
+        GATETERM5(xx, 0B10100, v10100) + GATETERM5(xx, 0B10101, v10101) +      \
+        GATETERM5(xx, 0B10110, v10110) + GATETERM5(xx, 0B10111, v10111) +      \
+        GATETERM5(xx, 0B11000, v11000) + GATETERM5(xx, 0B11001, v11001) +      \
+        GATETERM5(xx, 0B11010, v11010) + GATETERM5(xx, 0B11011, v11011) +      \
+        GATETERM5(xx, 0B11100, v11100) + GATETERM5(xx, 0B11101, v11101) +      \
+        GATETERM5(xx, 0B11110, v11110) + GATETERM5(xx, 0B11111, v11111)
+template <class PrecisionT> struct apply5QubitOpFunctor {
+    using ComplexT = Kokkos::complex<PrecisionT>;
+    using KokkosComplexVector = Kokkos::View<ComplexT *>;
+    using KokkosIntVector = Kokkos::View<std::size_t *>;
+
+    KokkosComplexVector arr;
+    KokkosComplexVector matrix;
+    KokkosIntVector wires;
+    KokkosIntVector parity;
+    KokkosIntVector rev_wire_shifts;
+    const std::size_t n_wires = 5;
+    const std::size_t dim = one << n_wires;
+    std::size_t num_qubits;
+
+    apply5QubitOpFunctor(KokkosComplexVector arr_, std::size_t num_qubits_,
+                         const KokkosComplexVector &matrix_,
+                         const std::vector<std::size_t> &wires_) {
+        Kokkos::View<const std::size_t *, Kokkos::HostSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+            wires_host(wires_.data(), wires_.size());
+        Kokkos::resize(wires, wires_host.size());
+        Kokkos::deep_copy(wires, wires_host);
+        arr = arr_;
+        matrix = matrix_;
+        num_qubits = num_qubits_;
+        std::tie(parity, rev_wire_shifts) = wires2Parity(num_qubits_, wires_);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const std::size_t k) const {
+        std::size_t i00000 = (k & parity(0));
+        for (std::size_t i = 1; i < parity.size(); i++) {
+            i00000 |= ((k << i) & parity(i));
+        }
+        ComplexT v00000 = arr(i00000);
+
+        std::size_t i00001 = i00000 | rev_wire_shifts(0);
+        ComplexT v00001 = arr(i00001);
+        std::size_t i00010 = i00000 | rev_wire_shifts(1);
+        ComplexT v00010 = arr(i00010);
+        std::size_t i00011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1);
+        ComplexT v00011 = arr(i00011);
+        std::size_t i00100 = i00000 | rev_wire_shifts(2);
+        ComplexT v00100 = arr(i00100);
+        std::size_t i00101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2);
+        ComplexT v00101 = arr(i00101);
+        std::size_t i00110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2);
+        ComplexT v00110 = arr(i00110);
+        std::size_t i00111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(2);
+        ComplexT v00111 = arr(i00111);
+        std::size_t i01000 = i00000 | rev_wire_shifts(3);
+        ComplexT v01000 = arr(i01000);
+        std::size_t i01001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(3);
+        ComplexT v01001 = arr(i01001);
+        std::size_t i01010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(3);
+        ComplexT v01010 = arr(i01010);
+        std::size_t i01011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(3);
+        ComplexT v01011 = arr(i01011);
+        std::size_t i01100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(3);
+        ComplexT v01100 = arr(i01100);
+        std::size_t i01101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
+                             rev_wire_shifts(3);
+        ComplexT v01101 = arr(i01101);
+        std::size_t i01110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
+                             rev_wire_shifts(3);
+        ComplexT v01110 = arr(i01110);
+        std::size_t i01111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(2) | rev_wire_shifts(3);
+        ComplexT v01111 = arr(i01111);
+        std::size_t i10000 = i00000 | rev_wire_shifts(4);
+        ComplexT v10000 = arr(i10000);
+        std::size_t i10001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(4);
+        ComplexT v10001 = arr(i10001);
+        std::size_t i10010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(4);
+        ComplexT v10010 = arr(i10010);
+        std::size_t i10011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(4);
+        ComplexT v10011 = arr(i10011);
+        std::size_t i10100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(4);
+        ComplexT v10100 = arr(i10100);
+        std::size_t i10101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
+                             rev_wire_shifts(4);
+        ComplexT v10101 = arr(i10101);
+        std::size_t i10110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
+                             rev_wire_shifts(4);
+        ComplexT v10110 = arr(i10110);
+        std::size_t i10111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(2) | rev_wire_shifts(4);
+        ComplexT v10111 = arr(i10111);
+        std::size_t i11000 = i00000 | rev_wire_shifts(3) | rev_wire_shifts(4);
+        ComplexT v11000 = arr(i11000);
+        std::size_t i11001 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(3) |
+                             rev_wire_shifts(4);
+        ComplexT v11001 = arr(i11001);
+        std::size_t i11010 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(3) |
+                             rev_wire_shifts(4);
+        ComplexT v11010 = arr(i11010);
+        std::size_t i11011 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(3) | rev_wire_shifts(4);
+        ComplexT v11011 = arr(i11011);
+        std::size_t i11100 = i00000 | rev_wire_shifts(2) | rev_wire_shifts(3) |
+                             rev_wire_shifts(4);
+        ComplexT v11100 = arr(i11100);
+        std::size_t i11101 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(2) |
+                             rev_wire_shifts(3) | rev_wire_shifts(4);
+        ComplexT v11101 = arr(i11101);
+        std::size_t i11110 = i00000 | rev_wire_shifts(1) | rev_wire_shifts(2) |
+                             rev_wire_shifts(3) | rev_wire_shifts(4);
+        ComplexT v11110 = arr(i11110);
+        std::size_t i11111 = i00000 | rev_wire_shifts(0) | rev_wire_shifts(1) |
+                             rev_wire_shifts(2) | rev_wire_shifts(3) |
+                             rev_wire_shifts(4);
+        ComplexT v11111 = arr(i11111);
+
+        arr(i00000) = GATESUM5(0B00000);
+        arr(i00001) = GATESUM5(0B00001);
+        arr(i00010) = GATESUM5(0B00010);
+        arr(i00011) = GATESUM5(0B00011);
+        arr(i00100) = GATESUM5(0B00100);
+        arr(i00101) = GATESUM5(0B00101);
+        arr(i00110) = GATESUM5(0B00110);
+        arr(i00111) = GATESUM5(0B00111);
+        arr(i01000) = GATESUM5(0B01000);
+        arr(i01001) = GATESUM5(0B01001);
+        arr(i01010) = GATESUM5(0B01010);
+        arr(i01011) = GATESUM5(0B01011);
+        arr(i01100) = GATESUM5(0B01100);
+        arr(i01101) = GATESUM5(0B01101);
+        arr(i01110) = GATESUM5(0B01110);
+        arr(i01111) = GATESUM5(0B01111);
+        arr(i10000) = GATESUM5(0B10000);
+        arr(i10001) = GATESUM5(0B10001);
+        arr(i10010) = GATESUM5(0B10010);
+        arr(i10011) = GATESUM5(0B10011);
+        arr(i10100) = GATESUM5(0B10100);
+        arr(i10101) = GATESUM5(0B10101);
+        arr(i10110) = GATESUM5(0B10110);
+        arr(i10111) = GATESUM5(0B10111);
+        arr(i11000) = GATESUM5(0B11000);
+        arr(i11001) = GATESUM5(0B11001);
+        arr(i11010) = GATESUM5(0B11010);
+        arr(i11011) = GATESUM5(0B11011);
+        arr(i11100) = GATESUM5(0B11100);
+        arr(i11101) = GATESUM5(0B11101);
+        arr(i11110) = GATESUM5(0B11110);
+        arr(i11111) = GATESUM5(0B11111);
+    }
+};
+
+} // namespace Pennylane::LightningKokkos::Functors
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Generator.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Generator.cpp
index f0e398ed87..8546ee8514 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Generator.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Generator.cpp
@@ -22,6 +22,7 @@
 
 #include <catch2/catch.hpp>
 
+#include "BasicGeneratorFunctors.hpp"
 #include "Constant.hpp"
 #include "ConstantUtil.hpp" // lookup, array_has_elem, prepend_to_tuple, tuple_to_array
 #include "StateVectorKokkos.hpp"
@@ -37,6 +38,7 @@
 namespace {
 using namespace Pennylane::Gates;
 using namespace Pennylane::LightningKokkos;
+using namespace Pennylane::LightningKokkos::Functors;
 using namespace Pennylane::Util;
 using std::size_t;
 } // namespace
@@ -44,13 +46,24 @@ using std::size_t;
 
 TEMPLATE_TEST_CASE("StateVectorKokkos::applyGenerator - errors",
                    "[StateVectorKokkos_Generator]", float, double) {
-    {
+    SECTION("applyGenerator") {
         const std::size_t num_qubits = 3;
         StateVectorKokkos<TestType> state_vector{num_qubits};
         PL_REQUIRE_THROWS_MATCHES(state_vector.applyGenerator("XXX", {0}),
                                   LightningException,
                                   "The given value does not exist.");
     }
+    SECTION("namedGeneratorFactor") {
+        using StateVectorT = StateVectorKokkos<TestType>;
+        using KokkosVector = StateVectorT::KokkosVector;
+        using ExecutionSpace = StateVectorT::KokkosExecSpace;
+        [[maybe_unused]] StateVectorT sv{1};
+        KokkosVector arr_("arr_", 2);
+        PL_REQUIRE_THROWS_MATCHES(applyNamedGenerator<ExecutionSpace>(
+                                      GeneratorOperation::END, arr_, 1, {0}),
+                                  LightningException,
+                                  "Generator operation does not exist.");
+    }
 }
 
 TEMPLATE_TEST_CASE("StateVectorKokkos::applyGenerator",
@@ -109,7 +122,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyGenerator",
         auto result_gate_svp = kokkos_gate_svp.getDataVector();
         auto result_gate_svm = kokkos_gate_svm.getDataVector();
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(-scale * imag(result_gntr_sv[j]) ==
                   Approx(0.5 *
                          (real(result_gate_svp[j]) - real(result_gate_svm[j])) /
@@ -198,7 +211,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyGeneratorDoubleExcitation",
             kokkos_gate_svm.DeviceToHost(result_gate_svm.data(),
                                          result_gate_svm.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(-scale * imag(result_gntr_sv[j]) ==
                       Approx(0.5 *
                              (real(result_gate_svp[j]) -
@@ -290,7 +303,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyGeneratorDoubleExcitationMinus",
             kokkos_gate_svm.DeviceToHost(result_gate_svm.data(),
                                          result_gate_svm.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(-scale * imag(result_gntr_sv[j]) ==
                       Approx(0.5 *
                              (real(result_gate_svp[j]) -
@@ -382,7 +395,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyGeneratorDoubleExcitationPlus",
             kokkos_gate_svm.DeviceToHost(result_gate_svm.data(),
                                          result_gate_svm.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(-scale * imag(result_gntr_sv[j]) ==
                       Approx(0.5 *
                              (real(result_gate_svp[j]) -
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_NonParam.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_NonParam.cpp
index d635092815..30c1822888 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_NonParam.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_NonParam.cpp
@@ -16,6 +16,7 @@
 #include <cstddef>
 #include <limits>
 #include <type_traits>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -25,6 +26,7 @@
 #include "Gates.hpp" // getHadamard
 #include "StateVectorKokkos.hpp"
 #include "TestHelpers.hpp"
+#include "TestHelpersWires.hpp"
 #include "Util.hpp"
 
 /**
@@ -36,8 +38,7 @@
 /// @cond DEV
 namespace {
 using namespace Pennylane::LightningKokkos;
-using namespace Pennylane::Gates; // getHadamard, getCNOT,
-                                  // getToffoli
+using namespace Pennylane::Gates;
 using namespace Pennylane::Util;
 using std::size_t;
 } // namespace
@@ -65,20 +66,61 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::CopyConstructor",
         kokkos_sv_2.DeviceToHost(kokkos_sv_2_host.data(),
                                  kokkos_sv_2.getLength());
 
-        for (size_t i = 0; i < kokkos_sv_1_host.size(); i++) {
+        for (std::size_t i = 0; i < kokkos_sv_1_host.size(); i++) {
             CHECK(kokkos_sv_1_host[i] == kokkos_sv_2_host[i]);
         }
     }
 }
 
-TEMPLATE_TEST_CASE("StateVectorKokkos::applyNamedOperation",
+TEMPLATE_TEST_CASE("StateVectorKokkos::applyOperation",
                    "[StateVectorKokkos_Nonparam]", float, double) {
     {
         const std::size_t num_qubits = 3;
         StateVectorKokkos<TestType> state_vector{num_qubits};
-        PL_REQUIRE_THROWS_MATCHES(state_vector.applyNamedOperation("XXX", {0}),
-                                  LightningException,
-                                  "The given value does not exist.");
+        PL_REQUIRE_THROWS_MATCHES(
+            state_vector.applyOperation("XXX", {0}), LightningException,
+            "Operation does not exist for XXX and no matrix provided.");
+    }
+}
+
+TEMPLATE_TEST_CASE("StateVectorKokkos::applyMatrix/Param-Operation",
+                   "[StateVectorKokkos_Nonparam]", float, double) {
+    using StateVectorT = StateVectorKokkos<TestType>;
+    using PrecisionT = StateVectorT::PrecisionT;
+
+    const std::size_t num_qubits = 4;
+    const TestType EP = 1e-4;
+    auto ini_st = createNonTrivialState<StateVectorT>(num_qubits);
+
+    std::unordered_map<std::string, GateOperation> str_to_gates_{};
+    for (const auto &[gate_op, gate_name] : Constant::gate_names) {
+        str_to_gates_.emplace(gate_name, gate_op);
+    }
+
+    const bool inverse = GENERATE(false, true);
+    const std::string gate_name =
+        GENERATE("Identity", "PauliX", "PauliY", "PauliZ", "Hadamard", "S", "T",
+                 "CNOT", "SWAP", "CY", "CZ", "CSWAP", "Toffoli");
+    {
+        auto gate_matrix = getMatrix<Kokkos::complex, PrecisionT>(
+            str_to_gates_.at(gate_name), {}, inverse);
+
+        StateVectorT kokkos_sv_ops{ini_st.data(), ini_st.size()};
+        StateVectorT kokkos_sv_mat{ini_st.data(), ini_st.size()};
+
+        const auto wires = createWires(str_to_gates_.at(gate_name), num_qubits);
+        kokkos_sv_ops.applyOperation(gate_name, wires, inverse, {});
+        kokkos_sv_mat.applyOperation("Matrix", wires, false, {}, gate_matrix);
+
+        auto result_ops = kokkos_sv_ops.getDataVector();
+        auto result_mat = kokkos_sv_mat.getDataVector();
+
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
+            CHECK(real(result_ops[j]) ==
+                  Approx(real(result_mat[j])).margin(EP));
+            CHECK(imag(result_ops[j]) ==
+                  Approx(imag(result_mat[j])).margin(EP));
+        }
     }
 }
 
@@ -106,7 +148,7 @@ TEMPLATE_PRODUCT_TEST_CASE("StateVectorKokkos::applyCY",
         auto result2 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{},
                                                            sv2.getView());
 
-        for (size_t j = 0; j < sv1.getView().size(); j++) {
+        for (std::size_t j = 0; j < sv1.getView().size(); j++) {
             CHECK(imag(result1[j]) == Approx(imag(result2[j])));
             CHECK(real(result1[j]) == Approx(real(result2[j])));
         }
@@ -119,7 +161,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyHadamard",
     {
         const std::size_t num_qubits = 3;
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv(num_qubits);
                 kokkos_sv.applyOperation("Hadamard", {index}, inverse);
                 Kokkos::complex<TestType> expected(1.0 / std::sqrt(2), 0);
@@ -134,7 +176,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyHadamard",
             const auto isqrt2 = ComplexT{INVSQRT2<TestType>()};
             const std::vector<ComplexT> matrix = {isqrt2, isqrt2, isqrt2,
                                                   -isqrt2};
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv(num_qubits);
                 kokkos_sv.applyOperation("Hadamard", {index}, inverse, {},
                                          matrix);
@@ -155,7 +197,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyPauliX",
         const std::size_t num_qubits = 3;
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("PauliX", {index}, false);
                 auto result_subview_0 = Kokkos::subview(kokkos_sv.getView(), 0);
@@ -195,14 +237,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyPauliY",
             {m, p, m, p, m, p, m, p}};
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperations(
                     {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
                     {{false}, {false}, {false}});
 
                 kokkos_sv.applyOperation("PauliY", {index}, false);
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     auto result_subview =
                         Kokkos::subview(kokkos_sv.getView(), j);
                     Kokkos::complex<TestType> result;
@@ -239,14 +281,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyPauliZ",
             {p, m, p, m, p, m, p, m}};
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperations(
                     {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
                     {{false}, {false}, {false}});
 
                 kokkos_sv.applyOperation("PauliZ", {index}, false);
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     auto result_subview =
                         Kokkos::subview(kokkos_sv.getView(), j);
                     Kokkos::complex<TestType> result;
@@ -282,13 +324,13 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyS", "[StateVectorKokkos_Nonparam]",
             {r, i, r, i, r, i, r, i}};
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperations(
                     {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
                     {{false}, {false}, {false}});
                 kokkos_sv.applyOperation("S", {index}, false);
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     auto result_subview =
                         Kokkos::subview(kokkos_sv.getView(), j);
                     Kokkos::complex<TestType> result;
@@ -329,14 +371,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyT", "[StateVectorKokkos_Nonparam]",
             {r, i, r, i, r, i, r, i}};
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < num_qubits; index++) {
+            for (std::size_t index = 0; index < num_qubits; index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperations(
                     {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
                     {{inverse}, {inverse}, {inverse}});
                 kokkos_sv.applyOperation("T", {index}, inverse);
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     auto result_subview =
                         Kokkos::subview(kokkos_sv.getView(), j);
                     Kokkos::complex<TestType> result;
@@ -369,7 +411,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyCNOT",
             Kokkos::deep_copy(kokkos_sv.getView(), ini_sv);
             auto result = Kokkos::create_mirror_view_and_copy(
                 Kokkos::HostSpace{}, kokkos_sv.getView());
-            for (size_t index = 1; index < num_qubits; index++) {
+            for (std::size_t index = 1; index < num_qubits; index++) {
                 kokkos_sv.applyOperation("CNOT", {index - 1, index}, false);
             }
             Kokkos::deep_copy(result, kokkos_sv.getView());
@@ -420,7 +462,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applySWAP",
                 auto sv10 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat10.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv01[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv01[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv10[j])));
@@ -444,7 +486,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applySWAP",
                 auto sv20 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat20.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv02[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv02[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv20[j])));
@@ -468,7 +510,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applySWAP",
                 auto sv21 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat21.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv12[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv12[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv21[j])));
@@ -514,7 +556,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyCZ", "[StateVectorKokkos_Nonparam]",
                 auto sv10 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat10.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv01[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv01[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv10[j])));
@@ -538,7 +580,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyCZ", "[StateVectorKokkos_Nonparam]",
                 auto sv20 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat20.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv02[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv02[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv20[j])));
@@ -562,7 +604,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyCZ", "[StateVectorKokkos_Nonparam]",
                 auto sv21 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat21.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv12[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv12[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv21[j])));
@@ -608,7 +650,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyToffoli",
                 auto sv102 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat102.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv012[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv012[j])));
                     CHECK(imag(expected_results[j]) == Approx(imag(sv102[j])));
@@ -640,7 +682,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyMultiQubitOp",
         auto sv_mq_host = Kokkos::create_mirror_view_and_copy(
             Kokkos::HostSpace{}, sv_mq.getView());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(sv_normal_host[j]) == Approx(imag(sv_mq_host[j])));
             CHECK(real(sv_normal_host[j]) == Approx(real(sv_mq_host[j])));
         }
@@ -661,7 +703,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyMultiQubitOp",
         auto sv_mq_host = Kokkos::create_mirror_view_and_copy(
             Kokkos::HostSpace{}, sv_mq.getView());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(sv_normal_host[j]) == Approx(imag(sv_mq_host[j])));
             CHECK(real(sv_normal_host[j]) == Approx(real(sv_mq_host[j])));
         }
@@ -682,7 +724,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyMultiQubitOp",
         auto sv_mq_host = Kokkos::create_mirror_view_and_copy(
             Kokkos::HostSpace{}, sv_mq.getView());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(sv_normal_host[j]) == Approx(imag(sv_mq_host[j])));
             CHECK(real(sv_normal_host[j]) == Approx(real(sv_mq_host[j])));
         }
@@ -690,7 +732,13 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyMultiQubitOp",
 
     SECTION("Three Qubit") {
         auto matrix = getToffoli<Kokkos::complex, TestType>();
-        std::vector<std::size_t> wires = {0, 1, 2};
+        std::vector<std::size_t> wires =
+            GENERATE(std::vector<std::size_t>{0, 1, 2},
+                     std::vector<std::size_t>{2, 0, 1},
+                     std::vector<std::size_t>{1, 2, 0},
+                     std::vector<std::size_t>{0, 2, 1},
+                     std::vector<std::size_t>{1, 0, 2},
+                     std::vector<std::size_t>{2, 1, 0});
         sv_normal.applyOperation("Toffoli", wires, inverse);
         auto sv_normal_host = Kokkos::create_mirror_view_and_copy(
             Kokkos::HostSpace{}, sv_normal.getView());
@@ -703,7 +751,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyMultiQubitOp",
         auto sv_mq_host = Kokkos::create_mirror_view_and_copy(
             Kokkos::HostSpace{}, sv_mq.getView());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(sv_normal_host[j]) == Approx(imag(sv_mq_host[j])));
             CHECK(real(sv_normal_host[j]) == Approx(real(sv_mq_host[j])));
         }
@@ -740,7 +788,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyCSWAP",
                 auto sv012 = Kokkos::create_mirror_view_and_copy(
                     Kokkos::HostSpace{}, svdat012.getView());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results[j]) == Approx(imag(sv012[j])));
                     CHECK(real(expected_results[j]) == Approx(real(sv012[j])));
                 }
@@ -771,7 +819,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::SetStateVector",
         };
         auto expected_state = init_state;
 
-        for (size_t i = 0; i < exp2(num_qubits - 1); i++) {
+        for (std::size_t i = 0; i < exp2(num_qubits - 1); i++) {
             std::swap(expected_state[i * 2], expected_state[i * 2 + 1]);
         }
 
@@ -794,7 +842,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::SetStateVector",
 
         kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(expected_state[j]) == Approx(imag(result_sv[j])));
             CHECK(real(expected_state[j]) == Approx(real(result_sv[j])));
         }
@@ -836,7 +884,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::SetIthStates",
 
         kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK(imag(expected_state[j]) == Approx(imag(result_sv[j])));
             CHECK(real(expected_state[j]) == Approx(real(result_sv[j])));
         }
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Param.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Param.cpp
index 095ee48ce3..91395caf8d 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Param.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_Param.cpp
@@ -17,17 +17,22 @@
 #include <limits>
 #include <random>
 #include <type_traits>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include <catch2/catch.hpp>
 
+#include "ConstantUtil.hpp"
+#include "Error.hpp"
+#include "GateFunctors.hpp"
 #include "Gates.hpp"
 #include "LinearAlgebraKokkos.hpp" // getRealOfComplexInnerProduct
 #include "MeasurementsKokkos.hpp"
 #include "ObservablesKokkos.hpp"
 #include "StateVectorKokkos.hpp"
 #include "TestHelpers.hpp"
+#include "TestHelpersWires.hpp"
 
 /**
  * @file
@@ -39,15 +44,78 @@
 namespace {
 using namespace Pennylane::Gates;
 using namespace Pennylane::LightningKokkos;
+using namespace Pennylane::LightningKokkos::Functors;
 using namespace Pennylane::LightningKokkos::Measures;
 using namespace Pennylane::LightningKokkos::Observables;
+using namespace Pennylane::Util;
 using Pennylane::LightningKokkos::Util::getRealOfComplexInnerProduct;
-using Pennylane::Util::createNonTrivialState;
-using Pennylane::Util::exp2;
 using std::size_t;
 } // namespace
 /// @endcond
 
+TEMPLATE_TEST_CASE("BasicGateFunctors::applyNamedOperation", "[Error]", float,
+                   double) {
+    using StateVectorT = StateVectorKokkos<TestType>;
+    using KokkosVector = StateVectorT::KokkosVector;
+    using ExecutionSpace = StateVectorT::KokkosExecSpace;
+    {
+        [[maybe_unused]] StateVectorT sv{1};
+        KokkosVector arr_("arr_", 2);
+        PL_REQUIRE_THROWS_MATCHES(applyNamedOperation<ExecutionSpace>(
+                                      GateOperation::END, arr_, 1, {0}),
+                                  LightningException,
+                                  "Gate operation does not exist.");
+    }
+}
+
+TEMPLATE_TEST_CASE("StateVectorKokkos::applyMatrix/Operation",
+                   "[StateVectorKokkos_Operation]", float, double) {
+    using StateVectorT = StateVectorKokkos<TestType>;
+    using PrecisionT = StateVectorT::PrecisionT;
+
+    const std::size_t num_qubits = 4;
+    const TestType EP = 1e-4;
+    const TestType param = 0.12342;
+    auto ini_st = createNonTrivialState<StateVectorT>(num_qubits);
+
+    std::unordered_map<std::string, GateOperation> str_to_gates_{};
+    for (const auto &[gate_op, gate_name] : Constant::gate_names) {
+        str_to_gates_.emplace(gate_name, gate_op);
+    }
+
+    const bool inverse = GENERATE(false, true);
+    const std::string gate_name = GENERATE(
+        "PhaseShift", "RX", "RY", "RZ", "ControlledPhaseShift", "CRX", "CRY",
+        "CRZ", "IsingXX", "IsingXY", "IsingYY", "IsingZZ", "SingleExcitation",
+        "SingleExcitationMinus", "SingleExcitationPlus", "DoubleExcitation",
+        "DoubleExcitationMinus", "DoubleExcitationPlus", "Rot", "CRot");
+    {
+        auto gate_op =
+            reverse_lookup(Constant::gate_names, std::string_view{gate_name});
+        auto num_params = lookup(Constant::gate_num_params, gate_op);
+        auto params = std::vector<PrecisionT>(num_params, param);
+        auto gate_matrix = getMatrix<Kokkos::complex, PrecisionT>(
+            str_to_gates_.at(gate_name), params, inverse);
+
+        StateVectorT kokkos_sv_ops{ini_st.data(), ini_st.size()};
+        StateVectorT kokkos_sv_mat{ini_st.data(), ini_st.size()};
+
+        const auto wires = createWires(str_to_gates_.at(gate_name), num_qubits);
+        kokkos_sv_ops.applyOperation(gate_name, wires, inverse, params);
+        kokkos_sv_mat.applyOperation("Matrix", wires, false, {}, gate_matrix);
+
+        auto result_ops = kokkos_sv_ops.getDataVector();
+        auto result_mat = kokkos_sv_mat.getDataVector();
+
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
+            CHECK(real(result_ops[j]) ==
+                  Approx(real(result_mat[j])).margin(EP));
+            CHECK(imag(result_ops[j]) ==
+                  Approx(imag(result_mat[j])).margin(EP));
+        }
+    }
+}
+
 TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingXY",
                    "[StateVectorKokkosManaged_Param]", float, double) {
     {
@@ -100,7 +168,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingXY",
             kokkos_sv.applyOperation("IsingXY", {0, 1}, false, {0.312});
             kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(expected[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(expected[j]) == Approx(real(result_sv[j])));
             }
@@ -131,14 +199,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRX",
                                   ComplexT{0, 0.867423225594017}}};
 
         SECTION("Apply adj directly") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
 
                 kokkos_sv.applyOperation("RX", {0}, true, {angles[index]});
                 kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results_adj[index][j]) ==
                           Approx(imag(result_sv[j])));
                     CHECK(real(expected_results_adj[index][j]) ==
@@ -174,7 +242,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRY",
                                      {0.0, -0.47942553860420306}};
 
         SECTION("Apply adj directly") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
 
@@ -182,7 +250,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRY",
                 kokkos_sv.applyOperation("RY", {0}, true, {angles[index]});
                 kokkos_sv.DeviceToHost(result_sv.data(), ini_st.size());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK(imag(expected_results_adj[index][j]) ==
                           Approx(imag(result_sv[j])));
                     CHECK(real(expected_results_adj[index][j]) ==
@@ -225,7 +293,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRZ",
              rz_data[2][0], rz_data[2][3], rz_data[2][0], rz_data[2][3]}};
 
         SECTION("Apply using dispatcher") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperations(
                     {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
@@ -234,7 +302,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRZ",
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j]) * 2 * std::sqrt(2)) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j]) * 2 * std::sqrt(2)) ==
@@ -278,7 +346,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyPhaseShift",
          ps_data[2][0], ps_data[2][3], ps_data[2][0], ps_data[2][3]}};
 
     SECTION("Apply using dispatcher") {
-        for (size_t index = 0; index < num_qubits; index++) {
+        for (std::size_t index = 0; index < num_qubits; index++) {
             StateVectorKokkos<TestType> kokkos_sv{num_qubits};
             kokkos_sv.applyOperations(
                 {{"Hadamard"}, {"Hadamard"}, {"Hadamard"}}, {{0}, {1}, {2}},
@@ -289,7 +357,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyPhaseShift",
             std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
             kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK((real(result_sv[j]) * 2 * std::sqrt(2)) ==
                       Approx(real(expected_results[index][j])));
                 CHECK((imag(result_sv[j]) * 2 * std::sqrt(2)) ==
@@ -314,7 +382,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyGlobalPhase",
         reinterpret_cast<ComplexT *>(sv_data.data()), sv_data.size());
     kokkos_sv.applyOperation("GlobalPhase", {index}, inverse, {param});
     auto result_sv = kokkos_sv.getDataVector();
-    for (size_t j = 0; j < exp2(num_qubits); j++) {
+    for (std::size_t j = 0; j < exp2(num_qubits); j++) {
         ComplexT tmp = phase * ComplexT(sv_data[j]);
         CHECK((real(result_sv[j])) == Approx(real(tmp)));
         CHECK((imag(result_sv[j])) == Approx(imag(tmp)));
@@ -347,7 +415,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyControlledGlobalPhase",
         reinterpret_cast<ComplexT *>(sv_data.data()), sv_data.size());
     kokkos_sv.applyOperation("C(GlobalPhase)", {index}, inverse, {}, phase);
     auto result_sv = kokkos_sv.getDataVector();
-    for (size_t j = 0; j < exp2(num_qubits); j++) {
+    for (std::size_t j = 0; j < exp2(num_qubits); j++) {
         ComplexT tmp = (inverse) ? conj(phase[j]) : phase[j];
         tmp *= ComplexT(sv_data[j]);
         CHECK((real(result_sv[j])) == Approx(real(tmp)));
@@ -386,7 +454,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyControlledPhaseShift",
         std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
         kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-        for (size_t j = 0; j < exp2(num_qubits); j++) {
+        for (std::size_t j = 0; j < exp2(num_qubits); j++) {
             CHECK((real(result_sv[j]) * 2 * std::sqrt(2)) ==
                   Approx(real(expected_results[1][j])));
             CHECK((imag(result_sv[j]) * 2 * std::sqrt(2)) ==
@@ -409,7 +477,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRot",
         std::vector<ComplexT>(0b1 << num_qubits),
         std::vector<ComplexT>(0b1 << num_qubits)};
 
-    for (size_t i = 0; i < angles.size(); i++) {
+    for (std::size_t i = 0; i < angles.size(); i++) {
         const auto rot_mat = getRot<Kokkos::complex, TestType>(
             angles[i][0], angles[i][1], angles[i][2]);
         expected_results[i][0] = rot_mat[0];
@@ -417,14 +485,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyRot",
     }
 
     SECTION("Apply using dispatcher") {
-        for (size_t index = 0; index < num_qubits; index++) {
+        for (std::size_t index = 0; index < num_qubits; index++) {
             StateVectorKokkos<TestType> kokkos_sv{num_qubits};
 
             kokkos_sv.applyOperation("Rot", {index}, false, angles[index]);
             std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
             kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK((real(result_sv[j])) ==
                       Approx(real(expected_results[index][j])));
                 CHECK((imag(result_sv[j])) ==
@@ -458,7 +526,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyCRot",
             std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
             kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK((real(result_sv[j])) ==
                       Approx(real(expected_results[j])));
                 CHECK((imag(result_sv[j])) ==
@@ -495,14 +563,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingXX",
     SECTION("Apply directly") {
         bool adjoint = GENERATE(false, true);
         SECTION("IsingXX 0,1") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingXX", {0, 1}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -512,14 +580,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingXX",
             }
         }
         SECTION("IsingXX 0,2") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingXX", {0, 2}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(
                               expected_results[index + angles.size()][j])));
@@ -561,14 +629,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingYY",
     SECTION("Apply directly") {
         bool adjoint = GENERATE(false, true);
         SECTION("IsingYY 0,1") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingYY", {0, 1}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -578,14 +646,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingYY",
             }
         }
         SECTION("IsingYY 0,2") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingYY", {0, 2}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(
                               expected_results[index + angles.size()][j])));
@@ -616,14 +684,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingZZ",
     SECTION("Apply directly") {
         bool adjoint = GENERATE(false, true);
         SECTION("IsingZZ 0,1") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingZZ", {0, 1}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -633,14 +701,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyIsingZZ",
             }
         }
         SECTION("IsingZZ 0,2") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("IsingZZ", {0, 2}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -668,14 +736,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyMultiRZ",
     SECTION("Apply directly") {
         bool adjoint = GENERATE(false, true);
         SECTION("MultiRZ 0,1") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("MultiRZ", {0, 1}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -685,14 +753,14 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyMultiRZ",
             }
         }
         SECTION("MultiRZ 0,2") {
-            for (size_t index = 0; index < angles.size(); index++) {
+            for (std::size_t index = 0; index < angles.size(); index++) {
                 StateVectorKokkos<TestType> kokkos_sv{num_qubits};
                 kokkos_sv.applyOperation("MultiRZ", {0, 2}, adjoint,
                                          {angles[index]});
                 std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
                 kokkos_sv.DeviceToHost(result_sv.data(), kokkos_sv.getLength());
 
-                for (size_t j = 0; j < exp2(num_qubits); j++) {
+                for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                     CHECK((real(result_sv[j])) ==
                           Approx(real(expected_results[index][j])));
                     CHECK((imag(result_sv[j])) ==
@@ -739,7 +807,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applySingleExcitation",
                                      {angle});
             kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(expected[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(expected[j]) == Approx(real(result_sv[j])));
             }
@@ -782,7 +850,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applySingleExcitationMinus",
                                      {angle});
             kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(expected[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(expected[j]) == Approx(real(result_sv[j])));
             }
@@ -825,7 +893,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applySingleExcitationPlus",
                                      {angle});
             kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(expected[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(expected[j]) == Approx(real(result_sv[j])));
             }
@@ -912,7 +980,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyDoubleExcitation",
             }
             kokkos_ref.DeviceToHost(result_ref.data(), result_ref.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(result_ref[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(result_ref[j]) == Approx(real(result_sv[j])));
             }
@@ -999,7 +1067,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyDoubleExcitationMinus",
             }
             kokkos_ref.DeviceToHost(result_ref.data(), result_ref.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(result_ref[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(result_ref[j]) == Approx(real(result_sv[j])));
             }
@@ -1086,7 +1154,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkosManaged::applyDoubleExcitationPlus",
             }
             kokkos_ref.DeviceToHost(result_ref.data(), result_ref.size());
 
-            for (size_t j = 0; j < exp2(num_qubits); j++) {
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
                 CHECK(imag(result_ref[j]) == Approx(imag(result_sv[j])));
                 CHECK(real(result_ref[j]) == Approx(real(result_sv[j])));
             }
@@ -1114,7 +1182,7 @@ TEMPLATE_TEST_CASE("Sample", "[StateVectorKokkosManaged_Param]", float,
     std::vector<std::vector<TestType>> phase;
 
     TestType initial_phase = 0.7;
-    for (size_t n_qubit = 0; n_qubit < num_qubits; n_qubit++) {
+    for (std::size_t n_qubit = 0; n_qubit < num_qubits; n_qubit++) {
         gates.emplace_back("RX");
         gates.emplace_back("RY");
 
@@ -1142,8 +1210,8 @@ TEMPLATE_TEST_CASE("Sample", "[StateVectorKokkosManaged_Param]", float,
     std::vector<std::size_t> samples_decimal(num_samples, 0);
 
     // convert samples to decimal and then bin them in counts
-    for (size_t i = 0; i < num_samples; i++) {
-        for (size_t j = 0; j < num_qubits; j++) {
+    for (std::size_t i = 0; i < num_samples; i++) {
+        for (std::size_t j = 0; j < num_qubits; j++) {
             if (samples[i * num_qubits + j] != 0) {
                 samples_decimal[i] += twos[(num_qubits - 1 - j)];
             }
@@ -1153,7 +1221,7 @@ TEMPLATE_TEST_CASE("Sample", "[StateVectorKokkosManaged_Param]", float,
 
     // compute estimated probabilities from histogram
     std::vector<TestType> probabilities(counts.size());
-    for (size_t i = 0; i < counts.size(); i++) {
+    for (std::size_t i = 0; i < counts.size(); i++) {
         probabilities[i] = counts[i] / (TestType)num_samples;
     }
 
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/ExpValFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/ExpValFunctors.hpp
index d7b8502cdb..54fa31c991 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/ExpValFunctors.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/ExpValFunctors.hpp
@@ -267,7 +267,7 @@ template <class PrecisionT> struct getExpectationValueSparseFunctor {
 
     KOKKOS_INLINE_FUNCTION
     void operator()(const std::size_t row, PrecisionT &expval) const {
-        for (size_t j = indptr[row]; j < indptr[row + 1]; j++) {
+        for (std::size_t j = indptr[row]; j < indptr[row + 1]; j++) {
             expval += real(conj(arr[row]) * data[j] * arr[indices[j]]);
         }
     }
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasurementsKokkos.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasurementsKokkos.hpp
index 88b52d4783..20f538df9a 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasurementsKokkos.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasurementsKokkos.hpp
@@ -106,7 +106,7 @@ class Measurements final
      * @param wires Wires to apply the observable to.
      */
     template <template <class> class functor_t, int num_wires>
-    PrecisionT applyExpValFunctor(const KokkosVector &matrix,
+    PrecisionT applyExpValFunctor(const KokkosVector matrix,
                                   const std::vector<std::size_t> &wires) {
         PL_ASSERT(wires.size() == num_wires);
         const std::size_t num_qubits = this->_statevector.getNumQubits();
@@ -128,7 +128,7 @@ class Measurements final
      * @return Expectation value with respect to observable applied to specified
      * wires.
      */
-    auto getExpValMatrix(const KokkosVector &matrix,
+    auto getExpValMatrix(const KokkosVector matrix,
                          const std::vector<std::size_t> &wires) -> PrecisionT {
         std::size_t num_qubits = this->_statevector.getNumQubits();
         std::size_t two2N = std::exp2(num_qubits - wires.size());
@@ -268,7 +268,7 @@ class Measurements final
             "The lengths of the list of operations and wires do not match.");
         std::vector<PrecisionT> expected_value_list;
 
-        for (size_t index = 0; index < operations_list.size(); index++) {
+        for (std::size_t index = 0; index < operations_list.size(); index++) {
             expected_value_list.emplace_back(
                 expval(operations_list[index], wires_list[index]));
         }
@@ -413,7 +413,7 @@ class Measurements final
 
         std::vector<PrecisionT> expected_value_list;
 
-        for (size_t index = 0; index < operations_list.size(); index++) {
+        for (std::size_t index = 0; index < operations_list.size(); index++) {
             expected_value_list.emplace_back(
                 var(operations_list[index], wires_list[index]));
         }
@@ -441,7 +441,7 @@ class Measurements final
                    const index_type *entries_ptr, const ComplexT *values_ptr,
                    const index_type numNNZ) {
         PL_ABORT_IF(
-            (this->_statevector.getLength() != (size_t(row_map_size) - 1)),
+            (this->_statevector.getLength() != (std::size_t(row_map_size) - 1)),
             "Statevector and Hamiltonian have incompatible sizes.");
 
         StateVectorT ob_sv{this->_statevector};
@@ -525,7 +525,7 @@ class Measurements final
 
         if (!is_sorted_wires) {
             sorted_ind_wires = Pennylane::Util::sorting_indices(wires);
-            for (size_t pos = 0; pos < wires.size(); pos++)
+            for (std::size_t pos = 0; pos < wires.size(); pos++)
                 sorted_wires[pos] = wires[sorted_ind_wires[pos]];
         }
 
@@ -541,12 +541,12 @@ class Measurements final
         Kokkos::View<PrecisionT *> d_probabilities("d_probabilities",
                                                    all_indices.size());
 
-        Kokkos::View<size_t *> d_sorted_ind_wires("d_sorted_ind_wires",
-                                                  sorted_ind_wires.size());
-        Kokkos::View<size_t *> d_all_indices("d_all_indices",
-                                             all_indices.size());
-        Kokkos::View<size_t *> d_all_offsets("d_all_offsets",
-                                             all_offsets.size());
+        Kokkos::View<std::size_t *> d_sorted_ind_wires("d_sorted_ind_wires",
+                                                       sorted_ind_wires.size());
+        Kokkos::View<std::size_t *> d_all_indices("d_all_indices",
+                                                  all_indices.size());
+        Kokkos::View<std::size_t *> d_all_offsets("d_all_offsets",
+                                                  all_offsets.size());
 
         Kokkos::deep_copy(
             d_all_indices,
@@ -586,8 +586,8 @@ class Measurements final
             Kokkos::View<PrecisionT *> transposed_tensor("transposed_tensor",
                                                          all_indices.size());
 
-            Kokkos::View<size_t *> d_trans_index("d_trans_index",
-                                                 all_indices.size());
+            Kokkos::View<std::size_t *> d_trans_index("d_trans_index",
+                                                      all_indices.size());
 
             const int num_trans_tensor = transposed_tensor.size();
             const int num_sorted_ind_wires = sorted_ind_wires.size();
@@ -636,7 +636,7 @@ class Measurements final
      *
      * @return Floating point std::vector with probabilities.
      */
-    std::vector<PrecisionT> probs(size_t num_shots) {
+    std::vector<PrecisionT> probs(std::size_t num_shots) {
         return BaseType::probs(num_shots);
     }
 
@@ -671,13 +671,14 @@ class Measurements final
      * be accessed using the stride sample_id*num_qubits, where sample_id is a
      * number between 0 and num_samples-1.
      */
-    auto generate_samples(size_t num_samples) -> std::vector<std::size_t> {
+    auto generate_samples(std::size_t num_samples) -> std::vector<std::size_t> {
         const std::size_t num_qubits = this->_statevector.getNumQubits();
         const std::size_t N = this->_statevector.getLength();
 
         Kokkos::View<ComplexT *> arr_data = this->_statevector.getView();
         Kokkos::View<PrecisionT *> probability("probability", N);
-        Kokkos::View<size_t *> samples("num_samples", num_samples * num_qubits);
+        Kokkos::View<std::size_t *> samples("num_samples",
+                                            num_samples * num_qubits);
 
         // Compute probability distribution from StateVector
         Kokkos::parallel_for(Kokkos::RangePolicy<KokkosExecSpace>(0, N),
@@ -708,7 +709,7 @@ class Measurements final
         std::vector<std::size_t> samples_h(num_samples * num_qubits);
 
         using UnmanagedSize_tHostView =
-            Kokkos::View<size_t *, Kokkos::HostSpace,
+            Kokkos::View<std::size_t *, Kokkos::HostSpace,
                          Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
 
         Kokkos::deep_copy(
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasuresFunctors.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasuresFunctors.hpp
index e0cc3c81d3..3718db6c46 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasuresFunctors.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/MeasuresFunctors.hpp
@@ -52,14 +52,15 @@ template <class PrecisionT> struct getProbFunctor {
 template <class PrecisionT, template <class ExecutionSpace> class GeneratorPool,
           class ExecutionSpace = Kokkos::DefaultExecutionSpace>
 struct Sampler {
-    Kokkos::View<size_t *> samples;
+    Kokkos::View<std::size_t *> samples;
     Kokkos::View<PrecisionT *> cdf;
     GeneratorPool<ExecutionSpace> rand_pool;
 
     const std::size_t num_qubits;
     const std::size_t length;
 
-    Sampler(Kokkos::View<size_t *> samples_, Kokkos::View<PrecisionT *> cdf_,
+    Sampler(Kokkos::View<std::size_t *> samples_,
+            Kokkos::View<PrecisionT *> cdf_,
             GeneratorPool<ExecutionSpace> rand_pool_,
             const std::size_t num_qubits_, const std::size_t length_)
         : samples(samples_), cdf(cdf_), rand_pool(rand_pool_),
@@ -95,7 +96,7 @@ struct Sampler {
             }
             index = high_idx - 1;
         }
-        for (size_t j = 0; j < num_qubits; j++) {
+        for (std::size_t j = 0; j < num_qubits; j++) {
             samples(k * num_qubits + (num_qubits - 1 - j)) = (index >> j) & 1U;
         }
     }
@@ -110,11 +111,11 @@ struct Sampler {
  * @param max_index_sorted_ind_wires_ Length of sorted_ind_wires.
  */
 struct getTransposedIndexFunctor {
-    Kokkos::View<size_t *> sorted_ind_wires;
-    Kokkos::View<size_t *> trans_index;
+    Kokkos::View<std::size_t *> sorted_ind_wires;
+    Kokkos::View<std::size_t *> trans_index;
     const std::size_t max_index_sorted_ind_wires;
-    getTransposedIndexFunctor(Kokkos::View<size_t *> sorted_ind_wires_,
-                              Kokkos::View<size_t *> trans_index_,
+    getTransposedIndexFunctor(Kokkos::View<std::size_t *> sorted_ind_wires_,
+                              Kokkos::View<std::size_t *> trans_index_,
                               const int length_sorted_ind_wires_)
         : sorted_ind_wires(sorted_ind_wires_), trans_index(trans_index_),
           max_index_sorted_ind_wires(length_sorted_ind_wires_ - 1) {}
@@ -141,10 +142,10 @@ struct getTransposedIndexFunctor {
 template <class PrecisionT> struct getTransposedFunctor {
     Kokkos::View<PrecisionT *> transProb;
     Kokkos::View<PrecisionT *> probability;
-    Kokkos::View<size_t *> trans_index;
+    Kokkos::View<std::size_t *> trans_index;
     getTransposedFunctor(Kokkos::View<PrecisionT *> transProb_,
                          Kokkos::View<PrecisionT *> probability_,
-                         Kokkos::View<size_t *> trans_index_)
+                         Kokkos::View<std::size_t *> trans_index_)
         : transProb(transProb_), probability(probability_),
           trans_index(trans_index_) {}
 
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Expval.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Expval.cpp
index 8143f621e4..37dd550415 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Expval.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Expval.cpp
@@ -264,7 +264,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::Hamiltonian_expval",
         std::size_t matrix_dim = static_cast<std::size_t>(1U) << num_qubits;
         std::vector<ComplexT> matrix(matrix_dim * matrix_dim);
 
-        for (size_t i = 0; i < matrix.size(); i++) {
+        for (std::size_t i = 0; i < matrix.size(); i++) {
             if (i % matrix_dim == i / matrix_dim)
                 matrix[i] = ComplexT{1, 0};
             else
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Measure.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Measure.cpp
index 3b525905db..a66634810a 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Measure.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/measurements/tests/Test_StateVectorKokkos_Measure.cpp
@@ -316,7 +316,7 @@ TEST_CASE("Test tensor transposition", "[Measure]") {
 
     using KokkosExecSpace = Kokkos::DefaultExecutionSpace;
     using UnmanagedSizeTHostView =
-        Kokkos::View<size_t *, Kokkos::HostSpace,
+        Kokkos::View<std::size_t *, Kokkos::HostSpace,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
 
     SECTION("Looping over different wire configurations:") {
@@ -328,11 +328,11 @@ TEST_CASE("Test tensor transposition", "[Measure]") {
 
             std::vector<std::size_t> results(indices.size());
 
-            Kokkos::View<size_t *> d_indices("d_indices", indices.size());
-            Kokkos::View<size_t *> d_results("d_results", indices.size());
-            Kokkos::View<size_t *> d_wires("d_wires", term.first.size());
-            Kokkos::View<size_t *> d_trans_index("d_trans_index",
-                                                 indices.size());
+            Kokkos::View<std::size_t *> d_indices("d_indices", indices.size());
+            Kokkos::View<std::size_t *> d_results("d_results", indices.size());
+            Kokkos::View<std::size_t *> d_wires("d_wires", term.first.size());
+            Kokkos::View<std::size_t *> d_trans_index("d_trans_index",
+                                                      indices.size());
 
             Kokkos::deep_copy(d_indices, UnmanagedSizeTHostView(
                                              indices.data(), indices.size()));
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/observables/ObservablesKokkos.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/observables/ObservablesKokkos.hpp
index 96de23c62c..8d35653918 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/observables/ObservablesKokkos.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/observables/ObservablesKokkos.hpp
@@ -189,7 +189,8 @@ class Hamiltonian final : public HamiltonianBase<StateVectorT> {
     void applyInPlace(StateVectorT &sv) const override {
         StateVectorT buffer{sv.getNumQubits()};
         buffer.initZeros();
-        for (size_t term_idx = 0; term_idx < this->coeffs_.size(); term_idx++) {
+        for (std::size_t term_idx = 0; term_idx < this->coeffs_.size();
+             term_idx++) {
             StateVectorT tmp{sv};
             this->obs_[term_idx]->applyInPlace(tmp);
             LightningKokkos::Util::axpy_Kokkos<PrecisionT>(
@@ -284,7 +285,7 @@ template <class StateVectorT, bool use_openmp> struct HamiltonianApplyInPlace {
         StateVectorT &sv) {
         KokkosVector res("results", sv.getLength());
         Kokkos::deep_copy(res, ComplexT{0.0, 0.0});
-        for (size_t term_idx = 0; term_idx < coeffs.size(); term_idx++) {
+        for (std::size_t term_idx = 0; term_idx < coeffs.size(); term_idx++) {
             StateVectorT tmp{sv};
             terms[term_idx]->applyInPlace(tmp);
             LightningKokkos::Util::axpy_Kokkos<PrecisionT>(
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/tests/Test_StateVectorLKokkos.cpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/tests/Test_StateVectorLKokkos.cpp
index 5fda1bfd1a..71f49896e6 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/tests/Test_StateVectorLKokkos.cpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/tests/Test_StateVectorLKokkos.cpp
@@ -133,7 +133,7 @@ TEMPLATE_PRODUCT_TEST_CASE("StateVectorKokkos::applyMatrix with a pointer",
     SECTION("Test with different number of wires") {
         using KokkosVector = typename StateVectorT::KokkosVector;
         const std::size_t num_qubits = 5;
-        for (size_t num_wires = 1; num_wires < num_qubits; num_wires++) {
+        for (std::size_t num_wires = 1; num_wires < num_qubits; num_wires++) {
             VectorT st_data_1 =
                 createRandomStateVectorData<PrecisionT>(re, num_qubits);
             VectorT st_data_2 = st_data_1;
@@ -247,7 +247,7 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::StateVectorKokkos",
     using ComplexT = typename StateVectorKokkos<PrecisionT>::ComplexT;
     std::mt19937_64 re{1337};
 
-    SECTION("StateVectorKokkos<TestType> {size_t}") {
+    SECTION("StateVectorKokkos<TestType> {std::size_t}") {
         REQUIRE(
             std::is_constructible_v<StateVectorKokkos<TestType>, std::size_t>);
         const std::size_t num_qubits = 4;
diff --git a/pennylane_lightning/core/src/simulators/lightning_kokkos/utils/LinearAlgebraKokkos.hpp b/pennylane_lightning/core/src/simulators/lightning_kokkos/utils/LinearAlgebraKokkos.hpp
index a274ee5c5c..d148f23be6 100644
--- a/pennylane_lightning/core/src/simulators/lightning_kokkos/utils/LinearAlgebraKokkos.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_kokkos/utils/LinearAlgebraKokkos.hpp
@@ -68,7 +68,7 @@ inline auto axpy_Kokkos(Kokkos::complex<PrecisionT> alpha,
  */
 template <class PrecisionT> struct SparseMV_KokkosFunctor {
     using KokkosVector = Kokkos::View<Kokkos::complex<PrecisionT> *>;
-    using KokkosSizeTVector = Kokkos::View<size_t *>;
+    using KokkosSizeTVector = Kokkos::View<std::size_t *>;
 
     KokkosVector x;
     KokkosVector y;
@@ -90,7 +90,7 @@ template <class PrecisionT> struct SparseMV_KokkosFunctor {
     KOKKOS_INLINE_FUNCTION
     void operator()(const std::size_t row) const {
         Kokkos::complex<PrecisionT> tmp = {0.0, 0.0};
-        for (size_t j = indptr[row]; j < indptr[row + 1]; j++) {
+        for (std::size_t j = indptr[row]; j < indptr[row + 1]; j++) {
             tmp += data[j] * x[indices[j]];
         }
         y[row] = tmp;
@@ -124,7 +124,7 @@ void SparseMV_Kokkos(Kokkos::View<ComplexT *> x, Kokkos::View<ComplexT *> y,
     using ConstSizeTHostView =
         Kokkos::View<const std::size_t *, Kokkos::HostSpace,
                      Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
-    using KokkosSizeTVector = Kokkos::View<size_t *>;
+    using KokkosSizeTVector = Kokkos::View<std::size_t *>;
     using KokkosVector = Kokkos::View<ComplexT *>;
 
     KokkosVector kok_data("kokkos_sparese_matrix_vals", numNNZ);