def test_from_object_equal_to_from_string(result_obj_1, result_str_1,
result_str_3):
assert GateModelQuantumTaskResult.from_object(
result_obj_1) == GateModelQuantumTaskResult.from_string(result_str_1)
assert GateModelQuantumTaskResult.from_object(
GateModelTaskResult.parse_raw(result_str_3)
) == GateModelQuantumTaskResult.from_string(result_str_3)
def test_run_gate_model():
dummy = DummyCircuitSimulator()
sim = LocalSimulator(dummy)
task = sim.run(Circuit().h(0).cnot(0, 1), 10)
dummy.assert_shots(10)
dummy.assert_qubits(2)
assert task.result() == GateModelQuantumTaskResult.from_object(GATE_MODEL_RESULT)
def _(circuit: Circuit, simulator: BraketSimulator, shots, *args, **kwargs):
if DeviceActionType.JAQCD not in simulator.properties.action:
raise NotImplementedError(
f"{type(simulator)} does not support qubit gate-based programs")
validate_circuit_and_shots(circuit, shots)
program = circuit.to_ir()
qubits = circuit.qubit_count
results = simulator.run(program, qubits, shots, *args, **kwargs)
return GateModelQuantumTaskResult.from_object(results)
def test_from_object_result_types(result_obj_5):
result_obj = result_obj_5
task_result = GateModelQuantumTaskResult.from_object(result_obj)
expected_measurements = np.asarray(result_obj.measurements, dtype=int)
assert np.array2string(task_result.measurements) == np.array2string(expected_measurements)
assert np.allclose(task_result.values[0], np.array([0.6, 0.4]))
assert task_result.values[1] == [0.4, 0.2, -0.2, -0.4]
assert task_result.result_types[0].type == jaqcd.Probability(targets=[1])
assert task_result.result_types[1].type == jaqcd.Expectation(observable=["z"])
def _(program: Program,
simulator: BraketSimulator,
shots: Optional[int] = None,
*args,
**kwargs):
if DeviceActionType.OPENQASM not in simulator.properties.action:
raise NotImplementedError(
f"{type(simulator)} does not support OpenQASM programs")
results = simulator.run(program, shots, *args, **kwargs)
return GateModelQuantumTaskResult.from_object(results)
def test_run_program_model():
dummy = DummyProgramSimulator()
sim = LocalSimulator(dummy)
task = sim.run(
Program(source="""
qubit[2] q;
bit[2] c;
h q[0];
cnot q[0], q[1];
c = measure q;
"""))
assert task.result() == GateModelQuantumTaskResult.from_object(
GATE_MODEL_RESULT)
def test_get_value_by_result_type(result_obj_4):
result = GateModelQuantumTaskResult.from_object(result_obj_4)
assert np.allclose(
result.get_value_by_result_type(ResultType.Probability(target=0)), result.values[0]
)
assert np.allclose(result.get_value_by_result_type(ResultType.StateVector()), result.values[1])
assert (
result.get_value_by_result_type(ResultType.Expectation(observable=Observable.Y(), target=0))
== result.values[2]
)
assert (
result.get_value_by_result_type(ResultType.Variance(observable=Observable.Y(), target=0))
== result.values[3]
)
assert result.get_value_by_result_type(ResultType.Amplitude(state=["00"])) == result.values[4]
def _(result: GateModelTaskResult) -> GateModelQuantumTaskResult:
GateModelQuantumTaskResult.cast_result_types(result)
return GateModelQuantumTaskResult.from_object(result)
def test_load_from_entry_point():
sim = LocalSimulator("dummy")
task = sim.run(Circuit().h(0).cnot(0, 1), 10)
assert task.result() == GateModelQuantumTaskResult.from_object(
GATE_MODEL_RESULT)
def _(result: GateModelTaskResult) -> GateModelQuantumTaskResult:
return GateModelQuantumTaskResult.from_object(result)
def test_get_value_by_result_type_value_error(result_obj_4):
result = GateModelQuantumTaskResult.from_object(result_obj_4)
result.get_value_by_result_type(ResultType.Probability(target=[0, 1]))
