UPDATE:

Dark-CodeX · Dark-CodeX · commit c97b0be6fd96 · 2025-03-07T22:16:33.000+05:30
1. using `C++20` feature `requires` to enforce that `n_qubits` is always greater than 0 at compile-time.
diff --git a/qubitverse/simulator/gates/gates.hh b/qubitverse/simulator/gates/gates.hh
@@ -14,6 +14,7 @@
 namespace simulator
 {
     template <std::size_t n_qubits = 1>
+        requires(n_qubits > 0)
     class qubit
     {
       public:
@@ -91,6 +92,7 @@ namespace simulator
     };
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     void qubit<n_qubits>::apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target)
     {
         const std::size_t stride = 1 << qubit_target; // Distance between paired indices
@@ -113,6 +115,7 @@ namespace simulator
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     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;
@@ -154,6 +157,7 @@ namespace simulator
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     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)
     {
         const std::size_t stride = 1 << qubit_target; // Distance between paired indices
@@ -178,6 +182,7 @@ namespace simulator
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     void qubit<n_qubits>::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)
     {
         if (n_qubits < 2)
@@ -235,134 +240,154 @@ namespace simulator
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits>::qubit()
     {
         this->M_qubits[0] = {1, 0};
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_identity(const std::size_t &q_target)
     {
         qubit::apply_predefined_gate(this->M_qubits, gate_type::IDENTITY, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_x(const std::size_t &q_target)
     {
         qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_X, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_y(const std::size_t &q_target)
     {
         qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Y, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_pauli_z(const std::size_t &q_target)
     {
         qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Z, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_hadamard(const std::size_t &q_target)
     {
         qubit::apply_predefined_gate(this->M_qubits, gate_type::HADAMARD, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_2_shift(const std::size_t &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>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_4_shift(const std::size_t &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>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_phase_general_shift(const double &_theta, const std::size_t &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>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_x(const double &_theta, const std::size_t &q_target)
     {
         qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_X, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_y(const double &_theta, const std::size_t &q_target)
     {
         qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Y, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_rotation_z(const double &_theta, const std::size_t &q_target)
     {
         qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Z, _theta, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_cnot(const std::size_t &q_control, const std::size_t &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>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_cz(const std::size_t &q_control, const std::size_t &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>
+        requires(n_qubits > 0)
     qubit<n_qubits> &qubit<n_qubits>::apply_swap(const std::size_t &q_control, const std::size_t &q_target)
     {
         qubit::apply_2qubit_gate(this->M_qubits, gate_type::SWAP_GATE, q_control, q_target);
         return *this;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     const qubit<n_qubits>::complex (&qubit<n_qubits>::get_qubits() const)[1 << n_qubits]
     {
         return this->M_qubits;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     const constexpr std::size_t qubit<n_qubits>::get_size() const
     {
         return 1 << n_qubits;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     const constexpr std::size_t qubit<n_qubits>::memory_consumption() const
     {
         return sizeof(complex) * (1 << n_qubits);
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     const constexpr std::size_t qubit<n_qubits>::no_of_qubits() const
     {
         return n_qubits;
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     void qubit<n_qubits>::get_nth_qubit(complex (&__s)[2], const std::size_t &nth) const
     {
         std::size_t mask = 1 << (n_qubits - nth - 1);
@@ -383,6 +408,7 @@ namespace simulator
     }
 
     template <std::size_t n_qubits>
+        requires(n_qubits > 0)
     std::size_t qubit<n_qubits>::measure()
     {
         double tot_prob = 0.0;

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`namespace simulator`
`15`	`15`	`{`
`16`	`16`	`template <std::size_t n_qubits = 1>`
	`17`	`+ requires(n_qubits > 0)`
`17`	`18`	`class qubit`
`18`	`19`	`{`
`19`	`20`	`public:`
`@@ -91,6 +92,7 @@ namespace simulator`
`91`	`92`	`};`
`92`	`93`
`93`	`94`	`template <std::size_t n_qubits>`
	`95`	`+ requires(n_qubits > 0)`
`94`	`96`	`void qubit<n_qubits>::apply_predefined_gate(complex (&__s)[1 << n_qubits], const gate_type &__g_type, const std::size_t &qubit_target)`
`95`	`97`	`{`
`96`	`98`	`const std::size_t stride = 1 << qubit_target; // Distance between paired indices`
`@@ -113,6 +115,7 @@ namespace simulator`
`113`	`115`	`}`
`114`	`116`
`115`	`117`	`template <std::size_t n_qubits>`
	`118`	`+ requires(n_qubits > 0)`
`116`	`119`	`qubit<n_qubits>::qgate_2x2 &qubit<n_qubits>::get_theta_gate(qgate_2x2 &__g, const gate_type &__g_type, const double &__theta)`
`117`	`120`	`{`
`118`	`121`	`__g.type = __g_type;`
`@@ -154,6 +157,7 @@ namespace simulator`
`154`	`157`	`}`
`155`	`158`
`156`	`159`	`template <std::size_t n_qubits>`
	`160`	`+ requires(n_qubits > 0)`
`157`	`161`	`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`	`162`	`{`
`159`	`163`	`const std::size_t stride = 1 << qubit_target; // Distance between paired indices`
`@@ -178,6 +182,7 @@ namespace simulator`
`178`	`182`	`}`
`179`	`183`
`180`	`184`	`template <std::size_t n_qubits>`
	`185`	`+ requires(n_qubits > 0)`
`181`	`186`	`void qubit<n_qubits>::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)`
`182`	`187`	`{`
`183`	`188`	`if (n_qubits < 2)`
`@@ -235,134 +240,154 @@ namespace simulator`
`235`	`240`	`}`
`236`	`241`
`237`	`242`	`template <std::size_t n_qubits>`
	`243`	`+ requires(n_qubits > 0)`
`238`	`244`	`qubit<n_qubits>::qubit()`
`239`	`245`	`{`
`240`	`246`	`this->M_qubits[0] = {1, 0};`
`241`	`247`	`}`
`242`	`248`
`243`	`249`	`template <std::size_t n_qubits>`
	`250`	`+ requires(n_qubits > 0)`
`244`	`251`	`qubit<n_qubits> &qubit<n_qubits>::apply_identity(const std::size_t &q_target)`
`245`	`252`	`{`
`246`	`253`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::IDENTITY, q_target);`
`247`	`254`	`return *this;`
`248`	`255`	`}`
`249`	`256`
`250`	`257`	`template <std::size_t n_qubits>`
	`258`	`+ requires(n_qubits > 0)`
`251`	`259`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_x(const std::size_t &q_target)`
`252`	`260`	`{`
`253`	`261`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_X, q_target);`
`254`	`262`	`return *this;`
`255`	`263`	`}`
`256`	`264`
`257`	`265`	`template <std::size_t n_qubits>`
	`266`	`+ requires(n_qubits > 0)`
`258`	`267`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_y(const std::size_t &q_target)`
`259`	`268`	`{`
`260`	`269`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Y, q_target);`
`261`	`270`	`return *this;`
`262`	`271`	`}`
`263`	`272`
`264`	`273`	`template <std::size_t n_qubits>`
	`274`	`+ requires(n_qubits > 0)`
`265`	`275`	`qubit<n_qubits> &qubit<n_qubits>::apply_pauli_z(const std::size_t &q_target)`
`266`	`276`	`{`
`267`	`277`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::PAULI_Z, q_target);`
`268`	`278`	`return *this;`
`269`	`279`	`}`
`270`	`280`
`271`	`281`	`template <std::size_t n_qubits>`
	`282`	`+ requires(n_qubits > 0)`
`272`	`283`	`qubit<n_qubits> &qubit<n_qubits>::apply_hadamard(const std::size_t &q_target)`
`273`	`284`	`{`
`274`	`285`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::HADAMARD, q_target);`
`275`	`286`	`return *this;`
`276`	`287`	`}`
`277`	`288`
`278`	`289`	`template <std::size_t n_qubits>`
	`290`	`+ requires(n_qubits > 0)`
`279`	`291`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_2_shift(const std::size_t &q_target)`
`280`	`292`	`{`
`281`	`293`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_2_SHIFT, q_target);`
`282`	`294`	`return *this;`
`283`	`295`	`}`
`284`	`296`
`285`	`297`	`template <std::size_t n_qubits>`
	`298`	`+ requires(n_qubits > 0)`
`286`	`299`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_pi_4_shift(const std::size_t &q_target)`
`287`	`300`	`{`
`288`	`301`	`qubit::apply_predefined_gate(this->M_qubits, gate_type::PHASE_PI_4_SHIFT, q_target);`
`289`	`302`	`return *this;`
`290`	`303`	`}`
`291`	`304`
`292`	`305`	`template <std::size_t n_qubits>`
	`306`	`+ requires(n_qubits > 0)`
`293`	`307`	`qubit<n_qubits> &qubit<n_qubits>::apply_phase_general_shift(const double &_theta, const std::size_t &q_target)`
`294`	`308`	`{`
`295`	`309`	`qubit::apply_theta_gate(this->M_qubits, gate_type::PHASE_GENERAL_SHIFT, _theta, q_target);`
`296`	`310`	`return *this;`
`297`	`311`	`}`
`298`	`312`
`299`	`313`	`template <std::size_t n_qubits>`
	`314`	`+ requires(n_qubits > 0)`
`300`	`315`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_x(const double &_theta, const std::size_t &q_target)`
`301`	`316`	`{`
`302`	`317`	`qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_X, _theta, q_target);`
`303`	`318`	`return *this;`
`304`	`319`	`}`
`305`	`320`
`306`	`321`	`template <std::size_t n_qubits>`
	`322`	`+ requires(n_qubits > 0)`
`307`	`323`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_y(const double &_theta, const std::size_t &q_target)`
`308`	`324`	`{`
`309`	`325`	`qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Y, _theta, q_target);`
`310`	`326`	`return *this;`
`311`	`327`	`}`
`312`	`328`
`313`	`329`	`template <std::size_t n_qubits>`
	`330`	`+ requires(n_qubits > 0)`
`314`	`331`	`qubit<n_qubits> &qubit<n_qubits>::apply_rotation_z(const double &_theta, const std::size_t &q_target)`
`315`	`332`	`{`
`316`	`333`	`qubit::apply_theta_gate(this->M_qubits, gate_type::ROTATION_Z, _theta, q_target);`
`317`	`334`	`return *this;`
`318`	`335`	`}`
`319`	`336`
`320`	`337`	`template <std::size_t n_qubits>`
	`338`	`+ requires(n_qubits > 0)`
`321`	`339`	`qubit<n_qubits> &qubit<n_qubits>::apply_cnot(const std::size_t &q_control, const std::size_t &q_target)`
`322`	`340`	`{`
`323`	`341`	`qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_NOT, q_control, q_target);`
`324`	`342`	`return *this;`
`325`	`343`	`}`
`326`	`344`
`327`	`345`	`template <std::size_t n_qubits>`
	`346`	`+ requires(n_qubits > 0)`
`328`	`347`	`qubit<n_qubits> &qubit<n_qubits>::apply_cz(const std::size_t &q_control, const std::size_t &q_target)`
`329`	`348`	`{`
`330`	`349`	`qubit::apply_2qubit_gate(this->M_qubits, gate_type::CONTROLLED_Z, q_control, q_target);`
`331`	`350`	`return *this;`
`332`	`351`	`}`
`333`	`352`
`334`	`353`	`template <std::size_t n_qubits>`
	`354`	`+ requires(n_qubits > 0)`
`335`	`355`	`qubit<n_qubits> &qubit<n_qubits>::apply_swap(const std::size_t &q_control, const std::size_t &q_target)`
`336`	`356`	`{`
`337`	`357`	`qubit::apply_2qubit_gate(this->M_qubits, gate_type::SWAP_GATE, q_control, q_target);`
`338`	`358`	`return *this;`
`339`	`359`	`}`
`340`	`360`
`341`	`361`	`template <std::size_t n_qubits>`
	`362`	`+ requires(n_qubits > 0)`
`342`	`363`	`const qubit<n_qubits>::complex (&qubit<n_qubits>::get_qubits() const)[1 << n_qubits]`
`343`	`364`	`{`
`344`	`365`	`return this->M_qubits;`
`345`	`366`	`}`
`346`	`367`
`347`	`368`	`template <std::size_t n_qubits>`
	`369`	`+ requires(n_qubits > 0)`
`348`	`370`	`const constexpr std::size_t qubit<n_qubits>::get_size() const`
`349`	`371`	`{`
`350`	`372`	`return 1 << n_qubits;`
`351`	`373`	`}`
`352`	`374`
`353`	`375`	`template <std::size_t n_qubits>`
	`376`	`+ requires(n_qubits > 0)`
`354`	`377`	`const constexpr std::size_t qubit<n_qubits>::memory_consumption() const`
`355`	`378`	`{`
`356`	`379`	`return sizeof(complex) * (1 << n_qubits);`
`357`	`380`	`}`
`358`	`381`
`359`	`382`	`template <std::size_t n_qubits>`
	`383`	`+ requires(n_qubits > 0)`
`360`	`384`	`const constexpr std::size_t qubit<n_qubits>::no_of_qubits() const`
`361`	`385`	`{`
`362`	`386`	`return n_qubits;`
`363`	`387`	`}`
`364`	`388`
`365`	`389`	`template <std::size_t n_qubits>`
	`390`	`+ requires(n_qubits > 0)`
`366`	`391`	`void qubit<n_qubits>::get_nth_qubit(complex (&__s)[2], const std::size_t &nth) const`
`367`	`392`	`{`
`368`	`393`	`std::size_t mask = 1 << (n_qubits - nth - 1);`
`@@ -383,6 +408,7 @@ namespace simulator`
`383`	`408`	`}`
`384`	`409`
`385`	`410`	`template <std::size_t n_qubits>`
	`411`	`+ requires(n_qubits > 0)`
`386`	`412`	`std::size_t qubit<n_qubits>::measure()`
`387`	`413`	`{`
`388`	`414`	`double tot_prob = 0.0;`