_test_util.py 文件源码

def check_phase_circuit(register_sizes,
                        expected_turns,
                        engine_list,
                        actions):
    """
    Args:
        register_sizes (list[int]):
        expected_turns (function(register_sizes: tuple[int],
                                 register_vals: tuple[int])):
        engine_list (list[projectq.cengines.BasicEngine]):
        actions (function(eng: MainEngine, registers: list[Qureg])):
    """

    sim = Simulator()
    rec = DummyEngine(save_commands=True)
    eng = MainEngine(backend=sim, engine_list=list(engine_list) + [rec])
    registers = [eng.allocate_qureg(size) for size in register_sizes]

    # Simulate all.
    for reg in registers:
        for q in reg:
            H | q
    rec.received_commands = []
    actions(eng, registers)

    state = np.array(sim.cheat()[1])
    magnitude_factor = math.sqrt(len(state))
    actions = list(rec.received_commands)
    for reg in registers:
        for q in reg:
            Measure | q

    # Compare.
    for i in range(len(state)):
        vals = []
        t = 0
        for r in register_sizes:
            vals.append((i >> t) & ((1 << r) - 1))
            t += r
        vals = tuple(vals)

        actual_factor = state[i]
        expected_turn = expected_turns(register_sizes, vals)
        actual_turn = cmath.phase(state[i]) / (2 * math.pi)
        delta_turn = abs((actual_turn - expected_turn + 0.5) % 1 - 0.5)
        if not (delta_turn < 0.00001):
            print(commands_to_ascii_circuit(actions))
            print("Register Sizes", register_sizes)
            print("Conflicting state: {}".format(vals))
            print("Expected phase: {} deg".format(float(expected_turn)*360))
            print("Actual phase: {} deg".format(actual_turn*360))
        assert abs(abs(actual_factor * magnitude_factor) - 1) < 0.00001
        assert delta_turn < 0.00001