changed sahred dictionary to a singleton object

Author: benjione

eqsn/gates.py

@@ -3,9 +3,7 @@
 from eqsn.qubit_thread import SINGLE_GATE, MERGE_SEND, MERGE_ACCEPT, MEASURE,\
                 MEASURE_NON_DESTRUCTIVE, GIVE_QUBITS_AND_TERMINATE, \
                 CONTROLLED_GATE, QubitThread
-from eqsn.shared_dict import get_queues_for_ids, set_thread_with_id, \
-    send_all_threads, stop_all_threads, \
-    change_thread_and_queue_of_ids_and_join, delete_id_and_check_to_join_thread
+from eqsn.shared_dict import SharedDict
 
 
 class EQSN(object):
@@ -17,6 +15,7 @@ class EQSN(object):
 
     def __init__(self):
         self.manager = multiprocessing.Manager()
+        self.shared_dict = SharedDict.get_instance()
 
     def new_qubit(self, id):
         """
@@ -25,70 +24,70 @@ def new_qubit(self, id):
         q = multiprocessing.Queue()
         thread = QubitThread(id, q)
         p = multiprocessing.Process(target=thread.run, args=())
-        set_thread_with_id(id, p, q)
+        self.shared_dict.set_thread_with_id(id, p, q)
         p.start()
 
     def stop_all(self):
         """
         Stops the simulator from running.
         """
-        send_all_threads(None)
-        stop_all_threads()
+        self.shared_dict.send_all_threads(None)
+        self.shared_dict.stop_all_threads()
 
     def X_gate(self, q_id):
         """
         Applies the Pauli X gate to the Qubit with q_id.
         """
         x = np.array([[0, 1], [1, 0]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def Y_gate(self, q_id):
         """
         Applies the Pauli Y gate to the Qubit with q_id.
         """
         x = np.array([[0, 0 - 1j], [0 + 1j, 0]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def Z_gate(self, q_id):
         """
         Applies the Pauli Z gate to the Qubit with q_id.
         """
         x = np.array([[1, 0], [0, -1]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def H_gate(self, q_id):
         """
         Applies the Hadamard gate to the Qubit with q_id.
         """
         x = (1 / 2.0) ** 0.5 * np.array([[1, 1], [1, -1]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def T_gate(self, q_id):
         """
         Applies the T gate to the Qubit with q_id.
         """
         x = np.array([[1, 0], [0, (0.7071067811865476 + 0.7071067811865475j)]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def S_gate(self, q_id):
         """
         Applies the S gate to the Qubit with q_id.
         """
         x = np.array([[1, 0], [0, 1j]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def K_gate(self, q_id):
         """
         Applies the K gate to the Qubit with q_id.
         """
         x = 0.5 * np.array([[1+1j, 1-1j], [-1+1j, -1-1j]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def RX_gate(self, q_id, rad):
@@ -98,7 +97,7 @@ def RX_gate(self, q_id, rad):
         mid = np.cos(rad / 2)
         other = -1j * np.sin(rad / 2)
         x = np.array([[mid, other], [other, mid]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def RY_gate(self, q_id, rad):
@@ -108,7 +107,7 @@ def RY_gate(self, q_id, rad):
         mid = np.cos(rad / 2)
         other = np.sin(rad / 2)
         x = np.array([[mid, -1.0 * other], [other, mid]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def RZ_gate(self, q_id, rad):
@@ -118,15 +117,15 @@ def RZ_gate(self, q_id, rad):
         top = np.exp(-1j * (rad / 2))
         bot = np.exp(1j * (rad / 2))
         x = np.array([[top, 0], [0, bot]], dtype=np.csingle)
-        q = get_queues_for_ids([q_id])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
     def merge_qubits(self, q_id1, q_id2):
         """
         Merges two qubits to one process, if they are not already
         running in the same process.
         """
-        l = get_queues_for_ids([q_id1, q_id2])
+        l = self.shared_dict.get_queues_for_ids([q_id1, q_id2])
         if len(l) == 1:
             return  # Already merged
         else:
@@ -139,7 +138,7 @@ def merge_qubits(self, q_id1, q_id2):
             qubits_q = self.manager.Queue()
             q1.put([GIVE_QUBITS_AND_TERMINATE, qubits_q])
             qubits = qubits_q.get()
-            change_thread_and_queue_of_ids_and_join(qubits, q_id2)
+            self.shared_dict.change_thread_and_queue_of_ids_and_join(qubits, q_id2)
 
     def cnot_gate(self, q_id1, q_id2):
         """
@@ -148,7 +147,7 @@ def cnot_gate(self, q_id1, q_id2):
         """
         x = np.array([[0, 1], [1, 0]], dtype=np.csingle)
         self.merge_qubits(q_id1, q_id2)
-        q = get_queues_for_ids([q_id1])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id1])[0]
         q.put([CONTROLLED_GATE, x, q_id1, q_id2])
 
     def cphase_gate(self, q_id1, q_id2):
@@ -158,7 +157,7 @@ def cphase_gate(self, q_id1, q_id2):
         """
         x = np.array([[0, 1], [0, -1]], dtype=np.csingle)
         self.merge_qubits(q_id1, q_id2)
-        q = get_queues_for_ids([q_id1])[0]
+        q = self.shared_dict.get_queues_for_ids([q_id1])[0]
         q.put([CONTROLLED_GATE, x, q_id1, q_id2])
 
     def measure(self, id, non_destructive=False):
@@ -168,12 +167,12 @@ def measure(self, id, non_destructive=False):
         measurement, but its wavefunction collapses.
         """
         ret = self.manager.Queue()
-        q = get_queues_for_ids([id])[0]
+        q = self.shared_dict.get_queues_for_ids([id])[0]
         if non_destructive:
             q.put([MEASURE_NON_DESTRUCTIVE, id, ret])
         else:
             q.put([MEASURE, id, ret])
         res = ret.get()
         if not non_destructive:
-            delete_id_and_check_to_join_thread(id)
+            self.shared_dict.delete_id_and_check_to_join_thread(id)
         return res