add some

qulacs · Nov 26, 2024 · 5fdedfd · 5fdedfd
1 parent 6ebff05
commit 5fdedfd
Show file tree

Hide file tree

Showing 5 changed files with 34 additions and 28 deletions.
diff --git a/scaluq/gate/gate_factory.hpp b/scaluq/gate/gate_factory.hpp
@@ -5,6 +5,7 @@
 #include "gate_pauli.hpp"
 #include "gate_probablistic.hpp"
 #include "gate_standard.hpp"
+#include "param_gate_probablistic.hpp"
 
 namespace scaluq {
 namespace internal {

diff --git a/scaluq/gate/gate_probablistic.hpp b/scaluq/gate/gate_probablistic.hpp
@@ -30,6 +30,9 @@ class ProbablisticGateImpl : public GateBase {
     }
     const std::vector<Gate>& gate_list() const { return _gate_list; }
     const std::vector<double>& distribution() const { return _distribution; }
+    const std::vector<double>& get_cumulative_distribution() const {
+        return _cumulative_distribution;
+    }
 
     std::vector<std::uint64_t> target_qubit_list() const override {
         throw std::runtime_error(

diff --git a/scaluq/gate/param_gate_probablistic.hpp b/scaluq/gate/param_gate_probablistic.hpp
@@ -34,6 +34,9 @@ class ParamProbablisticGateImpl : public ParamGateBase {
     }
     const std::vector<std::variant<Gate, ParamGate>>& gate_list() const { return _gate_list; }
     const std::vector<double>& distribution() const { return _distribution; }
+    const std::vector<double>& get_cumulative_distribution() const {
+        return _cumulative_distribution;
+    }
 
     std::vector<std::uint64_t> target_qubit_list() const override {
         throw std::runtime_error(

diff --git a/scaluq/simulator/noisesimulator.cpp b/scaluq/simulator/noisesimulator.cpp
@@ -104,15 +104,19 @@ std::vector<std::pair<StateVector, std::uint64_t>> NoiseSimulator::simulate(
                 if (!gate->is_noise()) {
                     gate->update_quantum_state(common_state);
                 } else {
-                    gate.gate_list()[current_gate_pos[done_itr]].update_quantum_state(common_state);
+                    ProbablisticGate prob_gate(gate);
+                    prob_gate->gate_list()[current_gate_pos[done_itr]]->update_quantum_state(
+                        common_state);
                 }
             } else {
                 auto p = std::get<std::pair<ParamGate, std::string>>(gate_variant);
-                const auto& gate = std::get<Gate>(gate_variant);
+                const auto& gate = p.first;
                 if (!gate->is_noise()) {
                     gate->update_quantum_state(common_state);
                 } else {
-                    gate.gate_list()[current_gate_pos[done_itr]].update_quantum_state(common_state);
+                    ParamProbablisticGate prob_gate(gate);
+                    prob_gate->gate_list()[current_gate_pos[done_itr]]->update_quantum_state(
+                        common_state);
                 }
             }
             done_itr++;
@@ -130,37 +134,31 @@ std::uint64_t NoiseSimulator::randomly_select_which_gate_pos_to_apply(const Gate
         return 0;
     }
 
-    if (auto* prob_gate = dynamic_cast<const internal::ProbablisticGateImpl*>(gate.get())) {
-        const auto& current_cumulative_distribution = prob_gate->get_cumulative_distribution();
+    ProbablisticGate prob_gate(gate);
+    const auto& current_cumulative_distribution = prob_gate->get_cumulative_distribution();
 
-        double tmp = _random.uniform();
-        auto gate_iterator = std::lower_bound(
-            current_cumulative_distribution.begin(), current_cumulative_distribution.end(), tmp);
-
-        auto gate_pos = std::distance(current_cumulative_distribution.begin(), gate_iterator);
-        return std::max(0UL, gate_pos - 1);
-    }
+    double tmp = _random.uniform();
+    auto gate_iterator = std::lower_bound(
+        current_cumulative_distribution.begin(), current_cumulative_distribution.end(), tmp);
 
-    return 0;
+    auto gate_pos = std::distance(current_cumulative_distribution.begin(), gate_iterator);
+    return std::max((std::uint64_t)0, (std::uint64_t)gate_pos - (std::uint64_t)1);
 }
 
 std::uint64_t NoiseSimulator::randomly_select_which_gate_pos_to_apply(const ParamGate& gate) {
     if (!gate->is_noise()) {
         return 0;
     }
 
-    if (auto* prob_gate = dynamic_cast<const internal::ProbablisticGateImpl*>(gate.get())) {
-        const auto& current_cumulative_distribution = prob_gate->get_cumulative_distribution();
+    ParamProbablisticGate prob_gate(gate);
+    const auto& current_cumulative_distribution = prob_gate->get_cumulative_distribution();
 
-        double tmp = _random.uniform();
-        auto gate_iterator = std::lower_bound(
-            current_cumulative_distribution.begin(), current_cumulative_distribution.end(), tmp);
+    double tmp = _random.uniform();
+    auto gate_iterator = std::lower_bound(
+        current_cumulative_distribution.begin(), current_cumulative_distribution.end(), tmp);
 
-        auto gate_pos = std::distance(current_cumulative_distribution.begin(), gate_iterator);
-        return std::max(0UL, gate_pos - 1);
-    }
-
-    return 0;
+    auto gate_pos = std::distance(current_cumulative_distribution.begin(), gate_iterator);
+    return std::max((std::uint64_t)0, (std::uint64_t)gate_pos - (std::uint64_t)1);
 }
 
 void NoiseSimulator::apply_gates(const std::vector<std::uint64_t>& chosen_gate,
@@ -173,11 +171,11 @@ void NoiseSimulator::apply_gates(const std::vector<std::uint64_t>& chosen_gate,
 
         if (std::holds_alternative<Gate>(gate_variant)) {
             const auto& gate = std::get<Gate>(gate_variant);
-            if (!gate.is_noise()) {
-                gate.update_quantum_state(sampling_state);
-            } else if (auto* prob_gate =
-                           dynamic_cast<const internal::ProbablisticGateImpl*>(gate.get())) {
-                prob_gate->gate_list()[chosen_gate[q]].update_quantum_state(sampling_state);
+            if (!gate->is_noise()) {
+                gate->update_quantum_state(sampling_state);
+            } else {
+                ProbablisticGate prob_gate(gate);
+                prob_gate->gate_list()[chosen_gate[q]]->update_quantum_state(sampling_state);
             }
         }
     }

diff --git a/scaluq/simulator/noisesimulator.hpp b/scaluq/simulator/noisesimulator.hpp
@@ -35,6 +35,7 @@ class NoiseSimulator {
         std::uint64_t sample_count);
 
     std::uint64_t randomly_select_which_gate_pos_to_apply(const Gate& gate);
+    std::uint64_t randomly_select_which_gate_pos_to_apply(const ParamGate& gate);
 
     std::vector<std::pair<StateVector, std::uint64_t>> simulate(
         const std::vector<std::unique_ptr<SamplingRequest>>& sampling_request_vector);