def test_division_is_converted_into_div_fn_call_instead_of_multiplication_by_reciprocal(
sympy_multiplication, expected_args):
# Important note about sympy: there is no Div operator (as opposed to
# e.g. Mul). The division on sympy expressions actually produces Mul
# objects, in which second operand is a reciprocal of the original one.
# We need to deal with this case, otherwise converting anything that
# contains division will result in very confusing expressions.
assert expression_from_sympy(sympy_multiplication) == FunctionCall(
"div", expected_args)
[
(quil.Parameter("theta"), Symbol("theta")),
(quil.Parameter("x"), Symbol("x")),
(quil.Parameter("x_1"), Symbol("x_1")),
],
)
def test_quil_parameters_are_converted_to_instance_of_symbol_with_correct_name(
pyquil_parameter, expected_symbol
):
assert expression_from_pyquil(pyquil_parameter) == expected_symbol
@pytest.mark.parametrize(
"pyquil_function_call, expected_function_call",
[
(quilatom.quil_cos(2), FunctionCall("cos", (2,))),
(
quilatom.quil_sin(quil.Parameter("theta")),
FunctionCall("sin", (Symbol("theta"),)),
),
(quilatom.quil_exp(quil.Parameter("x")), FunctionCall("exp", (Symbol("x"),))),
(quilatom.quil_sqrt(np.pi), FunctionCall("sqrt", (np.pi,))),
],
)
def test_pyquil_function_calls_are_converted_to_equivalent_function_call(
pyquil_function_call, expected_function_call
):
assert expression_from_pyquil(pyquil_function_call) == expected_function_call
@pytest.mark.parametrize(
def test_sympy_mul_is_converted_to_function_call_with_mul_operation(
sympy_mul, expected_args):
assert expression_from_sympy(sympy_mul) == FunctionCall(
"mul", expected_args)
def test_sympy_add_is_converted_to_function_call_with_add_operation(
sympy_add, expected_args):
assert expression_from_sympy(sympy_add) == FunctionCall(
"add", expected_args)
def test_sympy_power_with_negative_one_exponent_gets_converted_to_division(
sympy_power, expected_denominator):
assert expression_from_sympy(sympy_power) == FunctionCall(
"div", (1, expected_denominator))
def test_sympy_pow_is_converted_to_pow_function_call(sympy_power,
expected_args):
assert expression_from_sympy(sympy_power) == FunctionCall(
"pow", expected_args)
def test_add_resulting_from_subtraction_is_converted_to_sub_function_call(
sympy_addition, expected_args):
assert expression_from_sympy(sympy_addition) == FunctionCall(
"sub", expected_args)
def test_mul_not_from_division_is_not_classified_as_multiplication_by_reciprocal(
sympy_multiplication, ):
# Note: obviously you can manually construct multiplication that would
# be classified as multiplication by reciprocal. The bottom line of this
# test is: usual, simple multiplications are multiplications, not divisions.
assert not is_multiplication_by_reciprocal(sympy_multiplication)
@pytest.mark.parametrize(
"sympy_multiplication, expected_args",
[
(sympy.Symbol("x") / sympy.Symbol("y"), (Symbol("x"), Symbol("y"))),
(
sympy.Symbol("x") /
(sympy.Add(sympy.Symbol("z"), 1, evaluate=False)),
(Symbol("x"), FunctionCall("add", (Symbol("z"), 1))),
),
],
)
def test_division_is_converted_into_div_fn_call_instead_of_multiplication_by_reciprocal(
sympy_multiplication, expected_args):
# Important note about sympy: there is no Div operator (as opposed to
# e.g. Mul). The division on sympy expressions actually produces Mul
# objects, in which second operand is a reciprocal of the original one.
# We need to deal with this case, otherwise converting anything that
# contains division will result in very confusing expressions.
assert expression_from_sympy(sympy_multiplication) == FunctionCall(
"div", expected_args)
@pytest.mark.parametrize(