Add Some Tests and Examples

Author: adamisntdead

Code/Simulator/QuSim.py

@@ -1,6 +1,6 @@
 import random
-from math import e, log, pi, sqrt
 import string
+from math import e, log, pi, sqrt
 
 import numpy as np
 
@@ -81,7 +81,7 @@ def generateGate(gate, numQubits, qubit1, qubit2=-1):
         if (gate == 'CNOT' and qubit2 != -1):
             control = qubit1
             target = qubit2
-            
+
             # Generates List of Combinations of each qubit. there is 2n of them.
             # Returns List in string form, in the variable opts
             opts = []
@@ -97,35 +97,34 @@ def generateGate(gate, numQubits, qubit1, qubit2=-1):
                     mapList.append([index, -1])
                 else:
                     mapList.append([index, index])
-                    
+
             for j, index in enumerate(mapList):
                 if index[1] == -1:
                     # Takes the option and splits to each charachter
                     firstList = list(opts[index[0]])
-                    
+
                     # Figure out if looking for 0 or 1
                     toFlip = '0'
-                    if firstList[target-1] == '0':
+                    if firstList[target - 1] == '0':
                         toFlip = '1'
-                    elif firstList[target-1] == '1':
+                    elif firstList[target - 1] == '1':
                         toFlip = '0'
-                    
-                    
+
                     targetPattern = firstList
-                    targetPattern[target-1] = toFlip
+                    targetPattern[target - 1] = toFlip
                     # The String Searching For
                     targetPattern = string.join(targetPattern, '')
                     # The Index of the new strng
                     mapList[j][1] = opts.index(targetPattern)
-            
-            # Generate Empty Matrix To Use To Create New One 
+
+            # Generate Empty Matrix To Use To Create New One
             newMatrix = np.zeros((2**numQubits, 2**numQubits))
-            
-            # Go through the map of 1's and put them in 
+
+            # Go through the map of 1's and put them in
             for item in mapList:
                 newMatrix.itemset((item[0], item[1]), 1)
-            
-            return np.asmatrix(newMatrix)            
+
+            return np.asmatrix(newMatrix)
         else:
             # Put these here for handyness
             identity = gates.Id
@@ -180,7 +179,8 @@ def amps(self):
 
     def applyGate(self, gate, qubit1, qubit2=-1):
         if gate == 'CNOT':
-            gateMatrix = gates.generateGate(gate, self.numQubits, qubit1, qubit2)
+            gateMatrix = gates.generateGate(
+                gate, self.numQubits, qubit1, qubit2)
             self.amplitudes = np.dot(self.amplitudes, gateMatrix)
         else:
             # Qubit 1 is the target
@@ -213,10 +213,3 @@ def measure(self):
             )
             self.measured = True
             return self.value
-
-
-qureg = QuantumRegister(10)
-qureg.applyGate('X', 1)
-qureg.applyGate('X', 2)
-qureg.applyGate('CNOT', 1, 2)
-print(qureg.measure())

Code/Simulator/examples.py

@@ -0,0 +1,32 @@
+from QuSim import QuantumRegister
+
+#############################################
+#                 Introduction              #
+#############################################
+# Here Will Be A Few Example of Different   #
+# Quantum States / Algorithms, So You Can   #
+# Get A Feel For How The Module Works, and  #
+# Some Algorithmic Ideas                    #
+#############################################
+
+#############################################
+#                 Swap 2 Qubits             #
+#############################################
+# Here, We Will Apply a Pauli-X Gate / NOT Gate
+# To the first qubit, and then after the algorithm,
+# it will be swapped to the second qubit.
+
+Swap = QuantumRegister(2) # New Quantum Register of 2 qubits
+Swap.applyGate('X', 1) # Apply The NOT Gate. If Measured Now, it should be 10
+
+# Start the swap algorithm
+Swap.applyGate('CNOT', 1, 2)
+Swap.applyGate('H', 1)
+Swap.applyGate('H', 2)
+Swap.applyGate('CNOT', 1, 2)
+Swap.applyGate('H', 1)
+Swap.applyGate('H', 2)
+Swap.applyGate('CNOT', 1, 2)
+# End the swap algorithm
+
+print('SWAP: ' + Swap.measure()) # Measure the State, Should be 01

Code/Simulator/test.py

@@ -0,0 +1,49 @@
+import unittest
+import QuSim
+
+
+###########################################
+#                Cases                    #
+###########################################
+# Pauli-X Gate
+X = QuSim.QuantumRegister(1)
+X.applyGate('X', 1)
+
+# Multiple qubits
+Multi = QuSim.QuantumRegister(5)
+Multi.applyGate('X', 4)
+
+# CNOT Gates
+CNOT1 = QuSim.QuantumRegister(10)
+CNOT1.applyGate('CNOT', 3, 7)
+
+CNOT2 = QuSim.QuantumRegister(10)
+CNOT2.applyGate('X', 3)
+CNOT2.applyGate('CNOT', 3, 7)
+
+CNOT3 = QuSim.QuantumRegister(9)
+CNOT3.applyGate('X', 3)
+CNOT3.applyGate('X', 7)
+CNOT3.applyGate('CNOT', 3, 7)
+
+###########################################
+#                Tests                    #
+###########################################
+class QuSimTests(unittest.TestCase):
+    # X Gate
+    def testXGate(self):
+        self.assertEqual(X.measure(), '1')
+
+    def testMultipleQubits(self):
+        self.assertEqual(Multi.measure(), '00010')
+
+    def testCNOT(self):
+        self.assertEqual(CNOT1.measure(), '0000000000')
+        self.assertEqual(CNOT2.measure(), '0010001000')
+        self.assertEqual(CNOT3.measure(), '001000000')
+
+def main():
+    unittest.main()
+
+if __name__ == '__main__':
+    main()