UPDATE:

Dark-CodeX · Dark-CodeX · commit 26071f2cde89 · 2025-03-04T23:31:36.000+05:30
1. added new function `no_of_qubits()`
2. removed redundant template usage all over the code
diff --git a/qubitverse/simulator/gates/gates.hh b/qubitverse/simulator/gates/gates.hh
@@ -44,7 +44,7 @@ namespace simulator
             complex matrix[2][2]; // 2x2 matrix that stores various types of gates
         };
 
-        static inline const constexpr qgate_2x2 pre_defined_qgates[7] = {
+        static constexpr qgate_2x2 pre_defined_qgates[7] = {
             {IDENTITY, {{1, 0}, {0, 1}}},
             {PAULI_X, {{0, 1}, {1, 0}}},
             {PAULI_Y, {{0, {0, -1}}, {{0, 1}, 0}}},
@@ -55,13 +55,13 @@ namespace simulator
         };
 
         static void apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target);
-        static qgate_2x2 &get_theta_gate(qgate_2x2 &__g, const enum gate_type &__g_type, const double &__theta);
+        static qgate_2x2 &get_theta_gate(qgate_2x2 &__g, const gate_type &__g_type, const double &__theta);
         static void apply_theta_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const double &__theta, const std::size_t &qubit_target);
         static void apply_2qubit_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &q_control, const std::size_t &q_target);
 
       private:
         // a vector-space (hilbert-space) defined over complex numbers C
-        // 1 << n_qubit translates to 2^N, where N is the the number of qubit the hilbert-space(quantum-system) supports
+        // 1 << n_qubit translates to 2^N, where N is the number of qubit the hilbert-space(quantum-system) supports
         // memory consumption on x86_64 architecture for N-qubit system is: f(N) = 16 * 2^abs(N) bytes, that is exponential growth
         // Initially, the hilbert-space is defined as 1 + 0i, 0 + 0i, 0 + 0i, 0 + 0i, 0 + 0i, ..., 0 + 0i
         complex M_qubits[1 << n_qubits] = {};
@@ -85,16 +85,17 @@ namespace simulator
         const complex (&get_qubits() const)[1 << n_qubits];
         const constexpr std::size_t get_size() const;
         const constexpr std::size_t memory_consumption() const;
+        const constexpr std::size_t no_of_qubits() const;
         std::size_t measure();
         ~qubit() = default;
     };
 
     template <std::size_t n_qubits>
     void qubit<n_qubits>::apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target)
     {
-        std::size_t stride = 1 << qubit_target; // Distance between paired indices
+        const std::size_t stride = 1 << qubit_target; // Distance between paired indices
 
-        for (std::size_t i = 0; i < (1 << n_qubits); i += 2 * stride)
+        for (std::size_t i = 0; i < 1 << n_qubits; i += 2 * stride)
         {
             for (std::size_t j = 0; j < stride; ++j)
             {
@@ -105,40 +106,40 @@ namespace simulator
                 complex a = __s[idx0];
                 complex b = __s[idx1];
 
-                __s[idx0] = pre_defined_qgates[(std::size_t)__g_type].matrix[0][0] * a + pre_defined_qgates[(std::size_t)__g_type].matrix[0][1] * b;
-                __s[idx1] = pre_defined_qgates[(std::size_t)__g_type].matrix[1][0] * a + pre_defined_qgates[(std::size_t)__g_type].matrix[1][1] * b;
+                __s[idx0] = pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[0][0] * a + pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[0][1] * b;
+                __s[idx1] = pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[1][0] * a + pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[1][1] * b;
             }
         }
     }
 
     template <std::size_t n_qubits>
-    qubit<n_qubits>::qgate_2x2 &qubit<n_qubits>::get_theta_gate(qubit<n_qubits>::qgate_2x2 &__g, const enum gate_type &__g_type, const double &__theta)
+    qubit<n_qubits>::qgate_2x2 &qubit<n_qubits>::get_theta_gate(qgate_2x2 &__g, const gate_type &__g_type, const double &__theta)
     {
         __g.type = __g_type;
         switch (__g_type)
         {
-        case qubit<n_qubits>::gate_type::PHASE_GENERAL_SHIFT:
+        case gate_type::PHASE_GENERAL_SHIFT:
             __g.matrix[0][0] = 1.0;
             __g.matrix[0][1] = 0.0;
             __g.matrix[1][0] = 0.0;
             __g.matrix[1][1] = std::polar(1.0, __theta);
             break;
 
-        case qubit<n_qubits>::gate_type::ROTATION_X:
+        case gate_type::ROTATION_X:
             __g.matrix[0][0] = std::__complex_cos<double>(__theta / 2.0);
             __g.matrix[0][1] = (complex){0.0, -1.0} * std::__complex_sin<double>(__theta / 2.0);
             __g.matrix[1][0] = (complex){0.0, -1.0} * std::__complex_sin<double>(__theta / 2.0);
             __g.matrix[1][1] = std::__complex_cos<double>(__theta / 2.0);
             break;
 
-        case qubit<n_qubits>::gate_type::ROTATION_Y:
+        case gate_type::ROTATION_Y:
             __g.matrix[0][0] = std::__complex_cos<double>(__theta / 2.0);
             __g.matrix[0][1] = -std::__complex_sin<double>(__theta / 2.0);
             __g.matrix[1][0] = std::__complex_sin<double>(__theta / 2.0);
             __g.matrix[1][1] = std::__complex_cos<double>(__theta / 2.0);
             break;
 
-        case qubit<n_qubits>::gate_type::ROTATION_Z:
+        case gate_type::ROTATION_Z:
             __g.matrix[0][0] = std::polar(1.0, -__theta / 2.0);
             __g.matrix[0][1] = 0.0;
             __g.matrix[1][0] = 0.0;
@@ -148,19 +149,18 @@ namespace simulator
         default:
             std::fprintf(stderr, "error: invalid gate selected '%u'\n", (unsigned)__g_type);
             std::exit(EXIT_FAILURE);
-            break;
         }
         return __g;
     }
 
     template <std::size_t n_qubits>
     void qubit<n_qubits>::apply_theta_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const double &__theta, const std::size_t &qubit_target)
     {
-        std::size_t stride = 1 << qubit_target; // Distance between paired indices
-        qubit<n_qubits>::qgate_2x2 __g;
-        __g = qubit<n_qubits>::get_theta_gate(__g, __g_type, __theta);
+        const std::size_t stride = 1 << qubit_target; // Distance between paired indices
+        qgate_2x2 __g;
+        __g = qubit::get_theta_gate(__g, __g_type, __theta);
 
-        for (std::size_t i = 0; i < (1 << n_qubits); i += 2 * stride)
+        for (std::size_t i = 0; i < 1 << n_qubits; i += 2 * stride)
         {
             for (std::size_t j = 0; j < stride; ++j)
             {
@@ -186,7 +186,7 @@ namespace simulator
             std::exit(EXIT_FAILURE);
         }
 
-        if (__g_type == qubit<n_qubits>::gate_type::CONTROLLED_NOT)
+        if (__g_type == gate_type::CONTROLLED_NOT)
         {
             for (std::size_t i = 0; i < (1 << n_qubits); i++)
             {
@@ -201,7 +201,7 @@ namespace simulator
                 }
             }
         }
-        else if (__g_type == qubit<n_qubits>::gate_type::CONTROLLED_Z)
+        else if (__g_type == gate_type::CONTROLLED_Z)
         {
             for (std::size_t i = 0; i < (1 << n_qubits); i++)
             {
@@ -211,13 +211,13 @@ namespace simulator
                 }
             }
         }
-        else if (__g_type == qubit<n_qubits>::gate_type::SWAP_GATE)
+        else if (__g_type == gate_type::SWAP_GATE)
         {
             for (std::size_t i = 0; i < (1 << n_qubits); ++i)
             {
                 // Extract the bits at positions q_control and q_target.
-                std::size_t bit_q1 = (i >> q_control) & 1;
-                std::size_t bit_q2 = (i >> q_target) & 1;
+                const std::size_t bit_q1 = (i >> q_control) & 1;
+                const std::size_t bit_q2 = (i >> q_target) & 1;
 
                 // Only need to swap if the bits differ.
                 if (bit_q1 != bit_q2)
@@ -243,98 +243,98 @@ namespace simulator
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_identity(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::IDENTITY, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::IDENTITY, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_x(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_X, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_X, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_y(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_Y, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Y, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_z(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_Z, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Z, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_hadamard(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::HADAMARD, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::HADAMARD, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_2_shift(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_PI_2_SHIFT, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_2_SHIFT, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_4_shift(const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_PI_4_SHIFT, q_target);
+        qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_4_SHIFT, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_general_shift(const double &_theta, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_GENERAL_SHIFT, _theta, q_target);
+        qubit::apply_theta_gate(this->M_qubits, gate_type::PHASE_GENERAL_SHIFT, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_x(const double &_theta, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_X, _theta, q_target);
+        qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_X, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_y(const double &_theta, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_Y, _theta, q_target);
+        qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Y, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_z(const double &_theta, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_Z, _theta, q_target);
+        qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Z, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_cnot(const std::size_t &q_control, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::CONTROLLED_NOT, q_control, q_target);
+        qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_NOT, q_control, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_cz(const std::size_t &q_control, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::CONTROLLED_Z, q_control, q_target);
+        qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_Z, q_control, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
     qubit<n_qubits> &qubit<n_qubits>::apply_swap(const std::size_t &q_control, const std::size_t &q_target)
     {
-        qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::SWAP_GATE, q_control, q_target);
+        qubit::apply_2qubit_gate(this->M_qubits, gate_type::SWAP_GATE, q_control, q_target);
         return *this;
     }
 
@@ -353,7 +353,13 @@ namespace simulator
     template <std::size_t n_qubits>
     const constexpr std::size_t qubit<n_qubits>::memory_consumption() const
     {
-        return sizeof(qubit<n_qubits>::complex) * (1 << n_qubits);
+        return sizeof(complex) * (1 << n_qubits);
+    }
+
+    template <std::size_t n_qubits>
+    const constexpr std::size_t qubit<n_qubits>::no_of_qubits() const
+    {
+        return n_qubits;
     }
 
     template <std::size_t n_qubits>
@@ -367,7 +373,7 @@ namespace simulator
 
         std::random_device rd;
         std::mt19937 gen(rd());
-        std::uniform_real_distribution<double> dist(0.0, tot_prob);
+        std::uniform_real_distribution dist(0.0, tot_prob);
         double r = dist(gen);
 
         double accum = 0.0;

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ namespace simulator`
`44`	`44`	`complex matrix[2][2]; // 2x2 matrix that stores various types of gates`
`45`	`45`	`};`
`46`	`46`
`47`		`- static inline const constexpr qgate_2x2 pre_defined_qgates[7] = {`
	`47`	`+ static constexpr qgate_2x2 pre_defined_qgates[7] = {`
`48`	`48`	`{IDENTITY, {{1, 0}, {0, 1}}},`
`49`	`49`	`{PAULI_X, {{0, 1}, {1, 0}}},`
`50`	`50`	`{PAULI_Y, {{0, {0, -1}}, {{0, 1}, 0}}},`
`@@ -55,13 +55,13 @@ namespace simulator`
`55`	`55`	`};`
`56`	`56`
`57`	`57`	`static void apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target);`
`58`		`- static qgate_2x2 &get_theta_gate(qgate_2x2 &__g, const enum gate_type &__g_type, const double &__theta);`
	`58`	`+ static qgate_2x2 &get_theta_gate(qgate_2x2 &__g, const gate_type &__g_type, const double &__theta);`
`59`	`59`	`static void apply_theta_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const double &__theta, const std::size_t &qubit_target);`
`60`	`60`	`static void apply_2qubit_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &q_control, const std::size_t &q_target);`
`61`	`61`
`62`	`62`	`private:`
`63`	`63`	`// a vector-space (hilbert-space) defined over complex numbers C`
`64`		`- // 1 << n_qubit translates to 2^N, where N is the the number of qubit the hilbert-space(quantum-system) supports`
	`64`	`+ // 1 << n_qubit translates to 2^N, where N is the number of qubit the hilbert-space(quantum-system) supports`
`65`	`65`	`// memory consumption on x86_64 architecture for N-qubit system is: f(N) = 16 * 2^abs(N) bytes, that is exponential growth`
`66`	`66`	`// Initially, the hilbert-space is defined as 1 + 0i, 0 + 0i, 0 + 0i, 0 + 0i, 0 + 0i, ..., 0 + 0i`
`67`	`67`	`complex M_qubits[1 << n_qubits] = {};`
`@@ -85,16 +85,17 @@ namespace simulator`
`85`	`85`	`const complex (&get_qubits() const)[1 << n_qubits];`
`86`	`86`	`const constexpr std::size_t get_size() const;`
`87`	`87`	`const constexpr std::size_t memory_consumption() const;`
	`88`	`+ const constexpr std::size_t no_of_qubits() const;`
`88`	`89`	`std::size_t measure();`
`89`	`90`	`~qubit() = default;`
`90`	`91`	`};`
`91`	`92`
`92`	`93`	`template <std::size_t n_qubits>`
`93`	`94`	`void qubit<n_qubits>::apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target)`
`94`	`95`	`{`
`95`		`- std::size_t stride = 1 << qubit_target; // Distance between paired indices`
	`96`	`+ const std::size_t stride = 1 << qubit_target; // Distance between paired indices`
`96`	`97`
`97`		`- for (std::size_t i = 0; i < (1 << n_qubits); i += 2 * stride)`
	`98`	`+ for (std::size_t i = 0; i < 1 << n_qubits; i += 2 * stride)`
`98`	`99`	`{`
`99`	`100`	`for (std::size_t j = 0; j < stride; ++j)`
`100`	`101`	`{`
`@@ -105,40 +106,40 @@ namespace simulator`
`105`	`106`	`complex a = __s[idx0];`
`106`	`107`	`complex b = __s[idx1];`
`107`	`108`
`108`		`- __s[idx0] = pre_defined_qgates[(std::size_t)__g_type].matrix[0][0] * a + pre_defined_qgates[(std::size_t)__g_type].matrix[0][1] * b;`
`109`		`- __s[idx1] = pre_defined_qgates[(std::size_t)__g_type].matrix[1][0] * a + pre_defined_qgates[(std::size_t)__g_type].matrix[1][1] * b;`
	`109`	`+ __s[idx0] = pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[0][0] * a + pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[0][1] * b;`
	`110`	`+ __s[idx1] = pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[1][0] * a + pre_defined_qgates[static_cast<std::size_t>(__g_type)].matrix[1][1] * b;`
`110`	`111`	`}`
`111`	`112`	`}`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`template <std::size_t n_qubits>`
`115`		`- qubit<n_qubits>::qgate_2x2 &qubit<n_qubits>::get_theta_gate(qubit<n_qubits>::qgate_2x2 &__g, const enum gate_type &__g_type, const double &__theta)`
	`116`	`+ qubit<n_qubits>::qgate_2x2 &qubit<n_qubits>::get_theta_gate(qgate_2x2 &__g, const gate_type &__g_type, const double &__theta)`
`116`	`117`	`{`
`117`	`118`	`__g.type = __g_type;`
`118`	`119`	`switch (__g_type)`
`119`	`120`	`{`
`120`		`- case qubit<n_qubits>::gate_type::PHASE_GENERAL_SHIFT:`
	`121`	`+ case gate_type::PHASE_GENERAL_SHIFT:`
`121`	`122`	`__g.matrix[0][0] = 1.0;`
`122`	`123`	`__g.matrix[0][1] = 0.0;`
`123`	`124`	`__g.matrix[1][0] = 0.0;`
`124`	`125`	`__g.matrix[1][1] = std::polar(1.0, __theta);`
`125`	`126`	`break;`
`126`	`127`
`127`		`- case qubit<n_qubits>::gate_type::ROTATION_X:`
	`128`	`+ case gate_type::ROTATION_X:`
`128`	`129`	`__g.matrix[0][0] = std::__complex_cos<double>(__theta / 2.0);`
`129`	`130`	`__g.matrix[0][1] = (complex){0.0, -1.0} * std::__complex_sin<double>(__theta / 2.0);`
`130`	`131`	`__g.matrix[1][0] = (complex){0.0, -1.0} * std::__complex_sin<double>(__theta / 2.0);`
`131`	`132`	`__g.matrix[1][1] = std::__complex_cos<double>(__theta / 2.0);`
`132`	`133`	`break;`
`133`	`134`
`134`		`- case qubit<n_qubits>::gate_type::ROTATION_Y:`
	`135`	`+ case gate_type::ROTATION_Y:`
`135`	`136`	`__g.matrix[0][0] = std::__complex_cos<double>(__theta / 2.0);`
`136`	`137`	`__g.matrix[0][1] = -std::__complex_sin<double>(__theta / 2.0);`
`137`	`138`	`__g.matrix[1][0] = std::__complex_sin<double>(__theta / 2.0);`
`138`	`139`	`__g.matrix[1][1] = std::__complex_cos<double>(__theta / 2.0);`
`139`	`140`	`break;`
`140`	`141`
`141`		`- case qubit<n_qubits>::gate_type::ROTATION_Z:`
	`142`	`+ case gate_type::ROTATION_Z:`
`142`	`143`	`__g.matrix[0][0] = std::polar(1.0, -__theta / 2.0);`
`143`	`144`	`__g.matrix[0][1] = 0.0;`
`144`	`145`	`__g.matrix[1][0] = 0.0;`
`@@ -148,19 +149,18 @@ namespace simulator`
`148`	`149`	`default:`
`149`	`150`	`std::fprintf(stderr, "error: invalid gate selected '%u'\n", (unsigned)__g_type);`
`150`	`151`	`std::exit(EXIT_FAILURE);`
`151`		`- break;`
`152`	`152`	`}`
`153`	`153`	`return __g;`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`template <std::size_t n_qubits>`
`157`	`157`	`void qubit<n_qubits>::apply_theta_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const double &__theta, const std::size_t &qubit_target)`
`158`	`158`	`{`
`159`		`- std::size_t stride = 1 << qubit_target; // Distance between paired indices`
`160`		`- qubit<n_qubits>::qgate_2x2 __g;`
`161`		`- __g = qubit<n_qubits>::get_theta_gate(__g, __g_type, __theta);`
	`159`	`+ const std::size_t stride = 1 << qubit_target; // Distance between paired indices`
	`160`	`+ qgate_2x2 __g;`
	`161`	`+ __g = qubit::get_theta_gate(__g, __g_type, __theta);`
`162`	`162`
`163`		`- for (std::size_t i = 0; i < (1 << n_qubits); i += 2 * stride)`
	`163`	`+ for (std::size_t i = 0; i < 1 << n_qubits; i += 2 * stride)`
`164`	`164`	`{`
`165`	`165`	`for (std::size_t j = 0; j < stride; ++j)`
`166`	`166`	`{`
`@@ -186,7 +186,7 @@ namespace simulator`
`186`	`186`	`std::exit(EXIT_FAILURE);`
`187`	`187`	`}`
`188`	`188`
`189`		`- if (__g_type == qubit<n_qubits>::gate_type::CONTROLLED_NOT)`
	`189`	`+ if (__g_type == gate_type::CONTROLLED_NOT)`
`190`	`190`	`{`
`191`	`191`	`for (std::size_t i = 0; i < (1 << n_qubits); i++)`
`192`	`192`	`{`
`@@ -201,7 +201,7 @@ namespace simulator`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`	`}`
`204`		`- else if (__g_type == qubit<n_qubits>::gate_type::CONTROLLED_Z)`
	`204`	`+ else if (__g_type == gate_type::CONTROLLED_Z)`
`205`	`205`	`{`
`206`	`206`	`for (std::size_t i = 0; i < (1 << n_qubits); i++)`
`207`	`207`	`{`
`@@ -211,13 +211,13 @@ namespace simulator`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`}`
`214`		`- else if (__g_type == qubit<n_qubits>::gate_type::SWAP_GATE)`
	`214`	`+ else if (__g_type == gate_type::SWAP_GATE)`
`215`	`215`	`{`
`216`	`216`	`for (std::size_t i = 0; i < (1 << n_qubits); ++i)`
`217`	`217`	`{`
`218`	`218`	`// Extract the bits at positions q_control and q_target.`
`219`		`- std::size_t bit_q1 = (i >> q_control) & 1;`
`220`		`- std::size_t bit_q2 = (i >> q_target) & 1;`
	`219`	`+ const std::size_t bit_q1 = (i >> q_control) & 1;`
	`220`	`+ const std::size_t bit_q2 = (i >> q_target) & 1;`
`221`	`221`
`222`	`222`	`// Only need to swap if the bits differ.`
`223`	`223`	`if (bit_q1 != bit_q2)`
`@@ -243,98 +243,98 @@ namespace simulator`
`243`	`243`	`template <std::size_t n_qubits>`
`244`	`244`	`qubit<n_qubits> &qubit<n_qubits>::apply_identity(const std::size_t &q_target)`
`245`	`245`	`{`
`246`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::IDENTITY, q_target);`
	`246`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::IDENTITY, q_target);`
`247`	`247`	`return *this;`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`template <std::size_t n_qubits>`
`251`	`251`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_x(const std::size_t &q_target)`
`252`	`252`	`{`
`253`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_X, q_target);`
	`253`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_X, q_target);`
`254`	`254`	`return *this;`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`template <std::size_t n_qubits>`
`258`	`258`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_y(const std::size_t &q_target)`
`259`	`259`	`{`
`260`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_Y, q_target);`
	`260`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Y, q_target);`
`261`	`261`	`return *this;`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`template <std::size_t n_qubits>`
`265`	`265`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_z(const std::size_t &q_target)`
`266`	`266`	`{`
`267`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PAULI_Z, q_target);`
	`267`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Z, q_target);`
`268`	`268`	`return *this;`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`template <std::size_t n_qubits>`
`272`	`272`	`qubit<n_qubits> &qubit<n_qubits>::apply_hadamard(const std::size_t &q_target)`
`273`	`273`	`{`
`274`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::HADAMARD, q_target);`
	`274`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::HADAMARD, q_target);`
`275`	`275`	`return *this;`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`template <std::size_t n_qubits>`
`279`	`279`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_2_shift(const std::size_t &q_target)`
`280`	`280`	`{`
`281`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_PI_2_SHIFT, q_target);`
	`281`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_2_SHIFT, q_target);`
`282`	`282`	`return *this;`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`template <std::size_t n_qubits>`
`286`	`286`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_4_shift(const std::size_t &q_target)`
`287`	`287`	`{`
`288`		`- qubit<n_qubits>::apply_predefined_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_PI_4_SHIFT, q_target);`
	`288`	`+ qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_4_SHIFT, q_target);`
`289`	`289`	`return *this;`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`template <std::size_t n_qubits>`
`293`	`293`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_general_shift(const double &_theta, const std::size_t &q_target)`
`294`	`294`	`{`
`295`		`- qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::PHASE_GENERAL_SHIFT, _theta, q_target);`
	`295`	`+ qubit::apply_theta_gate(this->M_qubits, gate_type::PHASE_GENERAL_SHIFT, _theta, q_target);`
`296`	`296`	`return *this;`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`template <std::size_t n_qubits>`
`300`	`300`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_x(const double &_theta, const std::size_t &q_target)`
`301`	`301`	`{`
`302`		`- qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_X, _theta, q_target);`
	`302`	`+ qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_X, _theta, q_target);`
`303`	`303`	`return *this;`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`template <std::size_t n_qubits>`
`307`	`307`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_y(const double &_theta, const std::size_t &q_target)`
`308`	`308`	`{`
`309`		`- qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_Y, _theta, q_target);`
	`309`	`+ qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Y, _theta, q_target);`
`310`	`310`	`return *this;`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`template <std::size_t n_qubits>`
`314`	`314`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_z(const double &_theta, const std::size_t &q_target)`
`315`	`315`	`{`
`316`		`- qubit<n_qubits>::apply_theta_gate(this->M_qubits, qubit<n_qubits>::gate_type::ROTATION_Z, _theta, q_target);`
	`316`	`+ qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Z, _theta, q_target);`
`317`	`317`	`return *this;`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`template <std::size_t n_qubits>`
`321`	`321`	`qubit<n_qubits> &qubit<n_qubits>::apply_cnot(const std::size_t &q_control, const std::size_t &q_target)`
`322`	`322`	`{`
`323`		`- qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::CONTROLLED_NOT, q_control, q_target);`
	`323`	`+ qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_NOT, q_control, q_target);`
`324`	`324`	`return *this;`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`template <std::size_t n_qubits>`
`328`	`328`	`qubit<n_qubits> &qubit<n_qubits>::apply_cz(const std::size_t &q_control, const std::size_t &q_target)`
`329`	`329`	`{`
`330`		`- qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::CONTROLLED_Z, q_control, q_target);`
	`330`	`+ qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_Z, q_control, q_target);`
`331`	`331`	`return *this;`
`332`	`332`	`}`
`333`	`333`
`334`	`334`	`template <std::size_t n_qubits>`
`335`	`335`	`qubit<n_qubits> &qubit<n_qubits>::apply_swap(const std::size_t &q_control, const std::size_t &q_target)`
`336`	`336`	`{`
`337`		`- qubit<n_qubits>::apply_2qubit_gate(this->M_qubits, qubit<n_qubits>::gate_type::SWAP_GATE, q_control, q_target);`
	`337`	`+ qubit::apply_2qubit_gate(this->M_qubits, gate_type::SWAP_GATE, q_control, q_target);`
`338`	`338`	`return *this;`
`339`	`339`	`}`
`340`	`340`
`@@ -353,7 +353,13 @@ namespace simulator`
`353`	`353`	`template <std::size_t n_qubits>`
`354`	`354`	`const constexpr std::size_t qubit<n_qubits>::memory_consumption() const`
`355`	`355`	`{`
`356`		`- return sizeof(qubit<n_qubits>::complex) * (1 << n_qubits);`
	`356`	`+ return sizeof(complex) * (1 << n_qubits);`
	`357`	`+ }`
	`358`	`+`
	`359`	`+ template <std::size_t n_qubits>`
	`360`	`+ const constexpr std::size_t qubit<n_qubits>::no_of_qubits() const`
	`361`	`+ {`
	`362`	`+ return n_qubits;`
`357`	`363`	`}`
`358`	`364`
`359`	`365`	`template <std::size_t n_qubits>`
`@@ -367,7 +373,7 @@ namespace simulator`
`367`	`373`
`368`	`374`	`std::random_device rd;`
`369`	`375`	`std::mt19937 gen(rd());`
`370`		`- std::uniform_real_distribution<double> dist(0.0, tot_prob);`
	`376`	`+ std::uniform_real_distribution dist(0.0, tot_prob);`
`371`	`377`	`double r = dist(gen);`
`372`	`378`
`373`	`379`	`double accum = 0.0;`