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)))
