def test_build_let(self):
name = randomize.random_identifier()
value = randomize.random_integer()
sexpr = ("let", name, value)
exp_value = Constant(name, value)
act_value = build(sexpr)
self.assertEqual(exp_value, act_value)
def test_build_gate_with_constant(self):
gate_def = GateDefinition("g", [Parameter("p", None)])
sexpr = ("circuit", ("let", "a", 1), ("gate", "g", "a"))
exp_value = gate_def(Constant("a", 1))
circuit = build(sexpr, inject_pulses={"g": gate_def})
act_value = circuit.body.statements[0]
self.assertEqual(exp_value, act_value)
def test_build_map_slice_with_let(self):
sexpr = (
"circuit",
("let", "a", 0),
("let", "b", 3),
("let", "c", 2),
("register", "r", 3),
("map", "q", "r", "a", "b", "c"),
)
reg = Register("r", 3)
const_a = Constant("a", 0)
const_b = Constant("b", 3)
const_c = Constant("c", 2)
exp_value = Register(
"q", alias_from=reg, alias_slice=slice(const_a, const_b, const_c)
)
circuit = build(sexpr)
act_value = circuit.registers["q"]
self.assertEqual(exp_value, act_value)
def make_random_size_constant(name=None, value=None, return_params=False):
"""Make a random Constant that can represent a size"""
if name is None:
name = random_identifier()
if value is None:
value = random_whole()
const = Constant(name, value)
if not return_params:
return const
else:
return const, name, value
def test_build_map_with_let(self):
sexpr = (
"circuit",
("let", "a", 1),
("register", "r", 10),
("map", "q", "r", "a"),
)
reg = Register("r", 10)
const = Constant("a", 1)
exp_value = NamedQubit("q", reg, const)
circuit = build(sexpr)
act_value = circuit.registers["q"]
self.assertEqual(exp_value, act_value)
def test_create_fundamental_unknown_size(self):
"""Test creating a fundamental register with a size determined by a let constant."""
const, const_name, exp_size = common.make_random_size_constant(
return_params=True)
reg, exp_name, _ = common.make_random_register(size=const,
return_params=True)
self.assertEqual(exp_size, int(reg.size))
self.assertEqual(exp_name, reg.name)
self.assertTrue(reg.fundamental)
self.assertIsNone(reg.alias_from)
self.assertIsNone(reg.alias_slice)
new_size = random_whole()
new_const = Constant(const_name, new_size)
self.assertEqual(exp_size,
int(reg.resolve_size({const_name: new_const})))
def make_random_constant(name=None, value=None, return_params=False):
"""Make a random Constant value."""
if name is None:
name = random_identifier()
if value is None:
const_type = random.choice([ParamType.FLOAT, ParamType.INT])
if const_type == ParamType.FLOAT:
value = random_float()
elif const_type == ParamType.INT:
value = random_integer()
else:
assert False
const = Constant(name, value)
if not return_params:
return const
else:
return const, name, value
def test_build_circuit(self):
"""Build a circuit with as many features as possible."""
# We've already built a circuit elsewhere but this test tries to tie everything in together.
gate_def = GateDefinition("g", [Parameter("p", None)])
native_gates = {"g": gate_def}
sexpr = (
"circuit",
("register", "r", 7),
("map", "q", "r"),
("let", "x", 0),
("macro", "foo", "a", ("sequential_block", ("gate", "g", "a"))),
("gate", "foo", "x"),
("loop", 5, ("sequential_block", ("gate", "g", 3))),
("parallel_block", ("gate", "g", 0), ("gate", "g", 1)),
)
act_value = build(sexpr, inject_pulses=native_gates)
r = Register("r", 7)
q = Register("q", alias_from=r)
x = Constant("x", 0)
foo = core.Macro("foo", parameters=[Parameter("a", None)])
foo.body.statements.append(gate_def(Parameter("a", None)))
exp_value = core.Circuit(native_gates=native_gates)
exp_value.registers[r.name] = r
exp_value.registers[q.name] = q
exp_value.constants[x.name] = x
exp_value.macros[foo.name] = foo
exp_value.body.statements.append(foo(x))
loop_block = core.BlockStatement(statements=[gate_def(3),])
loop = core.LoopStatement(5, loop_block)
exp_value.body.statements.append(loop)
parallel_block = core.BlockStatement(parallel=True)
parallel_block.statements.append(gate_def(0))
parallel_block.statements.append(gate_def(1))
exp_value.body.statements.append(parallel_block)
self.assertEqual(exp_value, act_value)
def make_constant(self, name, value):
return Constant(name, value)