def NEG(classical_reg: MemoryReferenceDesignator) -> ClassicalNeg:
"""
Produce a NEG instruction.
:param classical_reg: A classical memory address to modify.
:return: A ClassicalNeg instance.
"""
return ClassicalNeg(unpack_classical_reg(classical_reg))
def unpack_reg_val_pair(
classical_reg1: MemoryReferenceDesignator,
classical_reg2: Union[MemoryReferenceDesignator, int, float],
) -> Tuple[MemoryReference, Union[MemoryReference, int, float]]:
"""
Helper function for typechecking / type-coercing arguments to constructors for binary classical
operators.
:param classical_reg1: Specifier for the classical memory address to be modified.
:param classical_reg2: Specifier for the second argument: a classical memory address or an
immediate value.
:return: A pair of pyQuil objects suitable for use as operands.
"""
left = unpack_classical_reg(classical_reg1)
if isinstance(classical_reg2, (float, int)):
return left, classical_reg2
return left, unpack_classical_reg(classical_reg2)
def STORE(region_name, offset_reg, source):
"""
Produce a STORE instruction.
:param region_name: Named region of memory to store to.
:param offset_reg: Offset into memory region. Must be a MemoryReference.
:param source: Source data. Can be either a MemoryReference or a constant.
:return: A ClassicalStore instance.
"""
return ClassicalStore(region_name, unpack_classical_reg(offset_reg), source)
def prepare_ternary_operands(classical_reg1, classical_reg2, classical_reg3):
"""
Helper function for typechecking / type-coercing arguments to constructors for ternary classical operators.
:param classical_reg1: Specifier for the classical memory address to be modified.
:param classical_reg2: Specifier for the left operand: a classical memory address.
:param classical_reg3: Specifier for the right operand: a classical memory address or an immediate value.
:return: A triple of pyQuil objects suitable for use as operands.
"""
if isinstance(classical_reg1, int):
raise TypeError("Target operand of comparison must be a memory address")
classical_reg1 = unpack_classical_reg(classical_reg1)
if isinstance(classical_reg2, int):
raise TypeError("Left operand of comparison must be a memory address")
classical_reg2 = unpack_classical_reg(classical_reg2)
if not isinstance(classical_reg3, int):
classical_reg3 = unpack_classical_reg(classical_reg3)
return classical_reg1, classical_reg2, classical_reg3
def MEASURE(qubit, classical_reg=None):
"""
Produce a MEASURE instruction.
:param qubit: The qubit to measure.
:param classical_reg: The classical register to measure into, or None.
:return: A Measurement instance.
"""
qubit = unpack_qubit(qubit)
address = None if classical_reg is None else unpack_classical_reg(classical_reg)
return Measurement(qubit, address)
def MEASURE(qubit: QubitDesignator, classical_reg: Optional[MemoryReferenceDesignator]) -> Measurement:
"""
Produce a MEASURE instruction.
:param qubit: The qubit to measure.
:param classical_reg: The classical register to measure into, or None.
:return: A Measurement instance.
"""
qubit = unpack_qubit(qubit)
if classical_reg is None:
address = None
else:
address = unpack_classical_reg(classical_reg)
return Measurement(qubit, address)
def RAW_CAPTURE(
frame: Frame,
duration: float,
memory_region: MemoryReferenceDesignator,
nonblocking: bool = False,
) -> RawCapture:
"""
Produce a RAW-CAPTURE instruction.
:param frame: The frame on which to capture raw values.
:param duration: The duration of the capture, in seconds.
:param memory_region: The classical memory region to store the resulting raw values.
:param nonblocking: A flag indicating whether the capture is NONBLOCKING.
:returns: A RawCapture instance.
"""
memory_region = unpack_classical_reg(memory_region)
return RawCapture(frame, duration, memory_region, nonblocking)
def CAPTURE(
frame: Frame,
kernel: Waveform,
memory_region: MemoryReferenceDesignator,
nonblocking: bool = False,
) -> Capture:
"""
Produce a CAPTURE instruction.
:param frame: The frame on which to capture an IQ value.
:param kernel: The integrating kernel for the capture.
:param memory_region: The classical memory region to store the resulting IQ value.
:param nonblocking: A flag indicating whether the capture is NONBLOCKING.
:returns: A Capture instance.
"""
memory_region = unpack_classical_reg(memory_region)
return Capture(frame, kernel, memory_region, nonblocking)
def if_then(
self,
classical_reg: MemoryReferenceDesignator,
if_program: "Program",
else_program: Optional["Program"] = None,
) -> "Program":
"""
If the classical register at index classical reg is 1, run if_program, else run
else_program.
Equivalent to the following construction:
.. code::
IF [c]:
instrA...
ELSE:
instrB...
=>
JUMP-WHEN @THEN [c]
instrB...
JUMP @END
LABEL @THEN
instrA...
LABEL @END
:param classical_reg: The classical register to check as the condition
:param if_program: A Quil program to execute if classical_reg is 1
:param else_program: A Quil program to execute if classical_reg is 0. This
argument is optional and defaults to an empty Program.
:returns: The Quil Program with the branching instructions added.
"""
else_program = else_program if else_program is not None else Program()
label_then = LabelPlaceholder("THEN")
label_end = LabelPlaceholder("END")
self.inst(
JumpWhen(target=label_then,
condition=unpack_classical_reg(classical_reg)))
self.inst(else_program)
self.inst(Jump(label_end))
self.inst(JumpTarget(label_then))
self.inst(if_program)
self.inst(JumpTarget(label_end))
return self
def MEASURE(qubit, classical_reg=None):
"""
Produce a MEASURE instruction.
:param qubit: The qubit to measure.
:param classical_reg: The classical register to measure into, or None.
:return: A Measurement instance.
"""
qubit = unpack_qubit(qubit)
if classical_reg is None:
address = None
elif isinstance(classical_reg, int):
warn("Indexing measurement addresses by integers is deprecated. " +
"Replacing this with the MemoryReference ro[i] instead.")
address = MemoryReference("ro", classical_reg)
else:
address = unpack_classical_reg(classical_reg)
return Measurement(qubit, address)
