Python QuantumProgram.set_api方法代码示例

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_setup_api(self):
        """Check the api is set up.

        If all correct is should be true.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        config = QP_program.get_api_config()
        self.assertTrue(config)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_local_backends_exist(self):
        """Test if there are local backends.

        If all correct some should exists (even if ofline).
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        local_backends = QP_program.local_backends()
        self.assertTrue(local_backends)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_online_backends_exist(self):
        """Test if there are online backends.

        If all correct some should exists.
        """
        # TODO: Jay should we check if we the QX is online before runing.
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        online_backends = QP_program.online_backends()
        # print(online_backends)
        self.assertTrue(online_backends)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_online_simulators(self):
        """Test if there are online backends (which are simulators).

        If all correct some should exists. NEED internet connection for this.
        """
        # TODO: Jay should we check if we the QX is online before runing.
        qp = QuantumProgram(specs=QPS_SPECS)
        qp.set_api(API_TOKEN, URL)
        online_simulators = qp.online_simulators()
        # print(online_simulators)
        self.assertTrue(isinstance(online_simulators, list))

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
 def test_quantum_program_online(self):
     qp = QuantumProgram()
     qr = qp.create_quantum_register('qr', 2)
     cr = qp.create_classical_register('cr', 2)
     qc = qp.create_circuit('qc', [qr], [cr])
     qc.h(qr[0])
     qc.measure(qr[0], cr[0])
     backend = 'ibmqx_qasm_simulator'  # the backend to run on
     shots = 1024  # the number of shots in the experiment.
     qp.set_api(self.QE_TOKEN, self.QE_URL)
     result = qp.execute(['qc'], backend=backend, shots=shots,
                         seed=78)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_get_backend_parameters(self):
        """Test get_backend_parameters.

        If all correct should return dictionay on length 4.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        backend_list = QP_program.online_backends()
        if backend_list:
            backend = backend_list[0]
        result = QP_program.get_backend_parameters(backend)
        # print(result)
        self.assertEqual(len(result), 4)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
 def test_execute_one_circuit_simulator_online(self):
     QP_program = QuantumProgram(specs=QPS_SPECS)
     qc = QP_program.get_circuit("circuitName")
     qr = QP_program.get_quantum_register("qname")
     cr = QP_program.get_classical_register("cname")
     qc.h(qr[1])
     qc.measure(qr[0], cr[0])
     shots = 1024  # the number of shots in the experiment.
     QP_program.set_api(API_TOKEN, URL)
     backend = QP_program.online_simulators()[0]
     # print(backend)
     result = QP_program.execute(['circuitName'], backend=backend,
                                 shots=shots, max_credits=3, silent=True)
     self.assertIsInstance(result, Result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
 def test_execute_several_circuits_simulator_online(self):
     QP_program = QuantumProgram(specs=QPS_SPECS)
     qr = QP_program.get_quantum_register("qname")
     cr = QP_program.get_classical_register("cname")
     qc2 = QP_program.create_circuit("qc2", [qr], [cr])
     qc3 = QP_program.create_circuit("qc3", [qr], [cr])
     qc2.h(qr[0])
     qc3.h(qr[0])
     qc2.measure(qr[0], cr[0])
     qc3.measure(qr[0], cr[0])
     circuits = ['qc2', 'qc3']
     shots = 1024  # the number of shots in the experiment.
     QP_program.set_api(API_TOKEN, URL)
     backend = QP_program.online_simulators()[0]
     result = QP_program.execute(circuits, backend=backend, shots=shots,
                                 max_credits=3, silent=True)
     self.assertIsInstance(result, Result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_execute_program_map(self):
        """Test execute_program_map.

        If all correct should return 10010.
        """
        QP_program = QuantumProgram()
        QP_program.set_api(API_TOKEN, URL)
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 100  # the number of shots in the experiment.
        max_credits = 3
        coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
        initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1),
                          ("q", 2): ("q", 2), ("q", 3): ("q", 3),
                          ("q", 4): ("q", 4)}
        QP_program.load_qasm_file(QASM_FILE_PATH_2, "circuit-dev")
        circuits = ["circuit-dev"]
        result = QP_program.execute(circuits, backend=backend, shots=shots,
                                    max_credits=max_credits,
                                    coupling_map=coupling_map,
                                    initial_layout=initial_layout, seed=5455)
        self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_execute_one_circuit_real_online(self):
        """Test execute_one_circuit_real_online.

        If all correct should return a result object
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 1, verbose=False)
        cr = QP_program.create_classical_register("cr", 1, verbose=False)
        qc = QP_program.create_circuit("circuitName", [qr], [cr])
        qc.h(qr)
        qc.measure(qr[0], cr[0])
        QP_program.set_api(API_TOKEN, URL)
        backend_list = QP_program.online_backends()
        if backend_list:
            backend = backend_list[0]
        shots = 1  # the number of shots in the experiment.
        status = QP_program.get_backend_status(backend)
        if status['available'] is False:
            pass
        else:
            result = QP_program.execute(['circuitName'], backend=backend,
                                        shots=shots, max_credits=3)
            self.assertIsInstance(result, Result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
    def test_add_circuit(self):
        """Test add two circuits.

        If all correct should return the data
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 2, verbose=False)
        cr = QP_program.create_classical_register("cr", 2, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [qr], [cr])
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        QP_program.set_api(API_TOKEN, URL)
        qc1.h(qr[0])
        qc1.measure(qr[0], cr[0])
        qc2.measure(qr[1], cr[1])
        new_circuit = qc1 + qc2
        QP_program.add_circuit('new_circuit', new_circuit)
        # new_circuit.measure(qr[0], cr[0])
        circuits = ['new_circuit']
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 1024  # the number of shots in the experiment.
        result = QP_program.execute(circuits, backend=backend, shots=shots,
                                    seed=78)
        self.assertEqual(result.get_counts('new_circuit'),
                         {'00': 505, '01': 519})

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
###############################################################
# Set the backend name and coupling map.
###############################################################
device = 'ibmqx2'
coupling_map = {0: [1, 2],
                1: [2],
                2: [],
                3: [2, 4],
                4: [2]}
circuits = ['initializer_circ']
shots = 1024

###############################################################
# Set up the API and execute the program.
###############################################################
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])

# Desired vector
print("Desired probabilities...")
print(str(list(map(lambda x: format(abs(x * x), '.3f'), desired_vector))))

# Initialize on local simulator
result = Q_program.execute(circuits,
                           backend='local_qasm_simulator',
                           wait=2, timeout=240, shots=shots)

print("Probabilities from simulator...[%s]" % result)
n_qubits_qureg = qr.size
counts = result.get_counts("initializer_circ")

qubit_strings = [format(i, '0%sb' % n_qubits_qureg) for

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
input_state(qft5, q, 5)
qft5.barrier()
qft(qft5, q, 5)
qft5.barrier()
for j in range(5):
    qft5.measure(q[j], c[j])

print(qft3.qasm())
print(qft4.qasm())
print(qft5.qasm())


###############################################################
# Set up the API and execute the program.
###############################################################
qp.set_api(Qconfig.APItoken, Qconfig.config["url"])

result = qp.execute(["qft3", "qft4", "qft5"], backend='ibmqx_qasm_simulator',
                    coupling_map=coupling_map, shots=1024)
print(result)
print(result.get_ran_qasm("qft3"))
print(result.get_ran_qasm("qft4"))
print(result.get_ran_qasm("qft5"))
print(result.get_counts("qft3"))
print(result.get_counts("qft4"))
print(result.get_counts("qft5"))


result = qp.execute(["qft3"], backend=backend,
                    coupling_map=coupling_map, shots=1024, timeout=120)
print(result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
import numpy as np
from qiskit import QuantumCircuit, QuantumProgram
import Qconfig


import qiskit.tools.qcvv.tomography as tomography

from qiskit.tools.visualization import plot_state, plot_histogram
from qiskit.tools.qi.qi import state_fidelity, concurrence, purity, outer

QProgram = QuantumProgram() 
QProgram.set_api(Qconfig.APItoken, Qconfig.config['url'])

qr = QProgram.create_quantum_register('qr',2)
cr = QProgram.create_classical_register('cr',2)

bell = QProgram.create_circuit('bell', [qr], [cr])
bell.h(qr[0])
bell.cx(qr[0], qr[1])

bell_result = QProgram.execute(['bell'], backend = 'local_qasm_simulator', shots = 1)
bell_psi = bell_result.get_data('bell') ['quantum_state']
bell_rho = outer(bell_psi)

plot_state(bell_rho, 'paulivec')

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import set_api [as 别名]
import Qconfig
from qiskit.backends import local_backends
from pprint import pprint
# Import your solution function
from challenge_submission import compiler_function

# Import submission evaluation and scoring functions
from challenge_evaluation import evaluate, score

# Possibly useful other helper function
from challenge_evaluation import qasm_to_dag_circuit, load_coupling, get_layout

# Select the simulation backend to calculate the quantum states resulting from the circuits
# On Windows platform the C++ Simulator is not yet available with pip install
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
pprint(qp.available_backends())
backend = 'local_qasm_simulator'


ex_nr = 1
test_circuit_filenames = {}


for i in range(ex_nr):
    test_circuit_filenames['circuits/random8_n5_d5.qasm'] = get_layout(5)
for i in range(ex_nr):
    test_circuit_filenames['circuits/random9_n16_d16.qasm'] = get_layout(16)
for i in range(ex_nr):
    test_circuit_filenames['circuits/random9_n20_d20.qasm'] = get_layout(20)