Merge remote-tracking branch 'IBMQuantum/Dev' into Dev

qiskit/_quantumprogram.py

@@ -270,47 +270,66 @@ class QuantumProgram(object):
 
             if job_result['status'] == 'Error':
                 return job_result
+            self.__qasm_compile['status'] = job_result['status']
+            self.__qasm_compile['used_credits'] = job_result['usedCredits']
         else:
-            self.run_local()
-            # return {"status": "Error", "result": "Not local simulations"}
+            if backend == 'local_qasm_simulator':
+                job_result = self.run_local_qasm_simulator()
+                self.__qasm_compile['status'] = job_result['status']
+            elif backend == 'local_unitary_simulator':
+                job_result = self.run_local_unitary_simulator()
+                self.__qasm_compile['status'] = job_result['status']
+            else:
+                return {"status": "Error", "result": "Not local simulations"}
 
         self.__qasm_compile['compiled_circuits'] = job_result['qasms']
+
         # print(self.__qasm_compile['compiled_circuits'])
-        self.__qasm_compile['used_credits'] = job_result['usedCredits']
         self.__qasm_compile['status'] = job_result['status']
 
-        # TODO: ISMAEL WHY NOT RETURN __qasm_compile rather than job_results.
-        return job_result
+        return self.__qasm_compile
 
-    def run_local(self):
-        """run_local, run a program (precompile of quantum circuits).
-        api the api for the device
-        device is a string for real or simulator
-        shots is the number of shots
-        max_credits is the credits of the experiments.
-        basis_gates are the base gates by default are: u1,u2,u3,cx,id
+    def run_local_qasm_simulator(self):
+        """run_local_qasm_simulator, run a program (precompile of quantum circuits).
         """
         shots = self.__qasm_compile['shots']
         qasms = self.__qasm_compile['compiled_circuits']
 
-        # /print(qasms)
-
         outcomes = {'qasms':[]}
         for qasm_circuit in qasms:
             basis = []
-            unroller = unroll.Unroller(qasm.Qasm(data=qasm_circuit['qasm']).parse(),SimulatorBackend(basis))
+            unroller = unroll.Unroller(qasm.Qasm(data=qasm_circuit['qasm']).parse(), SimulatorBackend(basis))
             unroller.backend.set_trace(False)
             unroller.execute()
             result = []
-            for i in range(shots):
-                b = QasmSimulator(unroller.backend.circuit, random.random()).run()
-                print('...............')
-                print(b)
-                print('...............')
-                result.append(bin(b['result']['classical_state'])[2:].zfill(b['number_of_cbits']))
-            qasm_circuit["result"]= {"data": {"counts":dict(Counter(result))}}
+            if shots == 1:
+                qasm_circuit = QasmSimulator(unroller.backend.circuit, random.random()).run()
+            else:
+                for i in range(shots):
+                    b = QasmSimulator(unroller.backend.circuit, random.random()).run()
+                    result.append(bin(b['result']['data']['classical_state'])[2:].zfill(b['number_of_cbits']))
+                qasm_circuit["result"] = {"data":{"counts":dict(Counter(result))}}
             outcomes['qasms'].append(qasm_circuit)
-        print(outcomes)
+        outcomes['status'] = 'COMPLETED'
+        return outcomes
+
+    def run_local_unitary_simulator(self):
+        """run_local_qasm_simulator, run a program (precompile of quantum circuits).
+        """
+        shots = self.__qasm_compile['shots']
+        qasms = self.__qasm_compile['compiled_circuits']
+        basis = []
+        outcomes = {'qasms':[]}
+        for qasm_circuit in qasms:
+
+            unroller = unroll.Unroller(qasm.Qasm(data=qasm_circuit['qasm']).parse(),
+                                       SimulatorBackend(basis))
+            unroller.backend.set_trace(False)  # print calls as they happen
+            unroller.execute()  # Here is where simulation happens
+            result = UnitarySimulator(unroller.backend.circuit).run()
+            qasm_circuit["result"] = {"data":{"unitary":result}}
+            outcomes['qasms'].append(qasm_circuit)
+        outcomes['status'] = 'COMPLETED'
         return outcomes
 
     def execute(self, circuits, device, shots=1024,

qiskit/simulators/_unitarysimulator.py

@@ -53,7 +53,7 @@ circuit =
         {
         'data':
             {
-            unitary: np.array([[ 0.70710678 +0.00000000e+00j
+            'unitary': np.array([[ 0.70710678 +0.00000000e+00j
                                  0.70710678 -8.65956056e-17j
                                  0.00000000 +0.00000000e+00j
                                  0.00000000 +0.00000000e+00j]

test/sim.py

@@ -19,9 +19,9 @@
 """Quick test program for unitary simulator backend."""
 import unittest
 
-from qiskit.simulators import UnitarySimulator
+
 from qiskit.qasm import Qasm
-from qiskit.simulators import UnitarySimulator
+from qiskit.simulators._unitarysimulator import UnitarySimulator
 import qiskit.unroll as unroll
 
 class TestQISKitSIM(unittest.TestCase):
@@ -35,6 +35,7 @@ class TestQISKitSIM(unittest.TestCase):
                                    UnitarySimulator(basis))
         unroller.backend.set_trace(True)  # print calls as they happen
         result = unroller.execute()  # Here is where simulation happens
+        print(result)
         self.assertEqual(result, 'TODO: check result')
 
 if __name__ == '__main__':

test/test.py

@@ -315,7 +315,7 @@ class TestQISKit(unittest.TestCase):
             API_TOKEN, URL)
         QP_program.compile(circuits, device, shots, credits, coupling_map)
         result = QP_program.run()
-        self.assertEqual(len(result), 10)
+        self.assertEqual(len(result), 6)
 
     def test_execute_program(self):
         QP_program = QuantumProgram(specs=QPS_SPECS)
@@ -338,7 +338,7 @@ class TestQISKit(unittest.TestCase):
 
         # QP_program.plotter()
 
-    def test_last(self):
+    def test_local_qasm_simulator(self):
         QP_program = QuantumProgram(specs=QPS_SPECS)
         qc, qr, cr = QP_program.quantum_elements()
         qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
@@ -353,9 +353,42 @@ class TestQISKit(unittest.TestCase):
         coupling_map = None
 
         result = QP_program.execute(circuits, device, shots)
-        print(result)
         self.assertEqual(result['status'], 'COMPLETED')
 
+    def test_local_qasm_simulator_one_shot(self):
+        QP_program = QuantumProgram(specs=QPS_SPECS)
+        qc, qr, cr = QP_program.quantum_elements()
+        qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
+        qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"])
+        qc2.h(qr[0])
+        qc3.h(qr[0])
+        circuits = [qc2, qc3]
+
+        device = 'local_qasm_simulator'  # the device to run on
+        shots = 1  # the number of shots in the experiment.
+        credits = 3
+        coupling_map = None
+        result = QP_program.execute(circuits, device, shots)
+        self.assertEqual(result['compiled_circuits'][0]['result']['data']['classical_state'], 0)
+
+    def test_local_unitary_simulator(self):
+        QP_program = QuantumProgram(specs=QPS_SPECS)
+        qc, qr, cr = QP_program.quantum_elements()
+        qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
+        qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"])
+        qc2.h(qr[0])
+        qc3.h(qr[0])
+        circuits = [qc2, qc3]
+
+        device = 'local_unitary_simulator'  # the device to run on
+        shots = 1  # the number of shots in the experiment.
+        credits = 3
+        coupling_map = None
+        result = QP_program.execute(circuits, device, shots)
+        # print(result)
+        self.assertIsNotNone(result['compiled_circuits'][0]['result']['data']['unitary'])
+
+
         # QP_program.plotter()
 
 

test/testsim.py

@@ -12,7 +12,7 @@ from collections import Counter
 import numpy as np
 
 basis = []  # empty basis, defaults to U, CX
-unroller = unroll.Unroller(Qasm(filename="example.qasm").parse(),
+unroller = unroll.Unroller(Qasm(filename="test/example.qasm").parse(),
                            SimulatorBackend(basis))
 unroller.backend.set_trace(False)  # print calls as they happen
 unroller.execute()  # Here is where simulation happens