def test_unary_classicals(): p = Program() p.inst(TRUE(0), FALSE(Addr(1)), NOT(Addr(2)), NEG(Addr(3))) assert p.out() == 'MOVE ro[0] 1\n' \ 'MOVE ro[1] 0\n' \ 'NOT ro[2]\n' \ 'NEG ro[3]\n'
def test_classical(): parse_equals("MOVE ro[0] 1", TRUE(0)) parse_equals("MOVE ro[0] 0", FALSE(0)) parse_equals("NOT ro[0]", NOT(Addr(0))) parse_equals("AND ro[0] 1", AND(MemoryReference("ro", 0), 1)) parse_equals("IOR ro[0] 1", OR(1, MemoryReference("ro", 0))) parse_equals("MOVE ro[0] 1", MOVE(MemoryReference("ro", 0), 1)) parse_equals("XOR ro[0] 1", XOR(MemoryReference("ro", 0), 1)) parse_equals("ADD mem[0] 1.2", ADD(MemoryReference("mem", 0), 1.2)) parse_equals("SUB mem[0] 1.2", SUB(MemoryReference("mem", 0), 1.2)) parse_equals("MUL mem[0] 1.2", MUL(MemoryReference("mem", 0), 1.2)) parse_equals("DIV mem[0] 1.2", DIV(MemoryReference("mem", 0), 1.2)) parse_equals( "EQ comp[1] ro[3] ro[2]", EQ(MemoryReference("comp", 1), MemoryReference("ro", 3), MemoryReference("ro", 2))) parse_equals( "LT comp[1] ro[3] ro[2]", LT(MemoryReference("comp", 1), MemoryReference("ro", 3), MemoryReference("ro", 2))) parse_equals( "LE comp[1] ro[3] ro[2]", LE(MemoryReference("comp", 1), MemoryReference("ro", 3), MemoryReference("ro", 2))) parse_equals( "GT comp[1] ro[3] ro[2]", GT(MemoryReference("comp", 1), MemoryReference("ro", 3), MemoryReference("ro", 2))) parse_equals( "GE comp[1] ro[3] ro[2]", GE(MemoryReference("comp", 1), MemoryReference("ro", 3), MemoryReference("ro", 2)))
def while_do(self, classical_reg, q_program): """ While a classical register at index classical_reg is 1, loop q_program Equivalent to the following construction: .. code:: WHILE [c]: instr... => LABEL @START JUMP-UNLESS @END [c] instr... JUMP @START LABEL @END :param int classical_reg: The classical register to check :param Program q_program: The Quil program to loop. :return: The Quil Program with the loop instructions added. :rtype: Program """ label_start = LabelPlaceholder("START") label_end = LabelPlaceholder("END") self.inst(JumpTarget(label_start)) self.inst(JumpUnless(target=label_end, condition=Addr(classical_reg))) self.inst(q_program) self.inst(Jump(label_start)) self.inst(JumpTarget(label_end)) return self
def test_measurement_calls(): p = Program() p.inst(MEASURE(0, 1), MEASURE(0, Addr(1))) assert p.out() == ('DECLARE ro BIT[2]\n' 'MEASURE 0 ro[1]\n' 'MEASURE 0 ro[1]\n')
def _addr(classical): # type: (QuilParser.AddrContext) -> MemoryReference if classical.IDENTIFIER() is not None: if classical.INT() is not None: return MemoryReference(str(classical.IDENTIFIER()), int(classical.INT().getText())) else: return MemoryReference(str(classical.IDENTIFIER()), 0) else: return Addr(int(classical.INT().getText()))
def FALSE(classical_reg): """ Produce a FALSE instruction. :param classical_reg: A classical register to modify. :return: An instruction object representing the equivalent MOVE. """ warn("`FALSE a` has been deprecated. Use `MOVE a 0` instead.") if isinstance(classical_reg, int): classical_reg = Addr(classical_reg) return MOVE(classical_reg, 0)
def TRUE(classical_reg: Union[MemoryReference, int]) -> ClassicalMove: """ Produce a TRUE instruction. :param classical_reg: A classical register to modify. :return: An instruction object representing the equivalent MOVE. """ warn("`TRUE a` has been deprecated. Use `MOVE a 1` instead.") if isinstance(classical_reg, int): classical_reg = Addr(classical_reg) return MOVE(classical_reg, 1)
def test_jumps(): parse_equals("LABEL @test_1", JumpTarget(Label("test_1"))) parse_equals("JUMP @test_1", Jump(Label("test_1"))) parse_equals("JUMP-WHEN @test_1 ro[0]", JumpWhen(Label("test_1"), Addr(0))) parse_equals("JUMP-UNLESS @test_1 ro[1]", JumpUnless(Label("test_1"), Addr(1)))
def test_binary_classicals(): p = Program() p.inst(AND(Addr(0), Addr(1)), OR(Addr(1), Addr(0)), MOVE(Addr(0), Addr(1)), CONVERT(Addr(0), Addr(1)), IOR(Addr(0), Addr(1)), XOR(Addr(0), Addr(1)), ADD(Addr(0), Addr(1)), SUB(Addr(0), Addr(1)), MUL(Addr(0), Addr(1)), DIV(Addr(0), Addr(1)), EXCHANGE(Addr(0), Addr(1))) assert p.out() == 'AND ro[0] ro[1]\n' \ 'IOR ro[0] ro[1]\n' \ 'MOVE ro[0] ro[1]\n' \ 'CONVERT ro[0] ro[1]\n' \ 'IOR ro[0] ro[1]\n' \ 'XOR ro[0] ro[1]\n' \ 'ADD ro[0] ro[1]\n' \ 'SUB ro[0] ro[1]\n'\ 'MUL ro[0] ro[1]\n' \ 'DIV ro[0] ro[1]\n' \ 'EXCHANGE ro[0] ro[1]\n'
def MEASURE(qubit) -> Addr: program_context().inst(gates.MEASURE(qubit, qubit)) return Addr(qubit)
def test_jumps(): _test("LABEL @test_1", JumpTarget(Label("test_1"))) _test("JUMP @test_1", Jump(Label("test_1"))) _test("JUMP-WHEN @test_1 [0]", JumpWhen(Label("test_1"), Addr(0))) _test("JUMP-UNLESS @test_1 [1]", JumpUnless(Label("test_1"), Addr(1)))