def test_isclose_different_terms():
a = QubitOperator(((1, 'Y'),), -0.1j)
b = QubitOperator(((1, 'X'),), -0.1j)
assert a.isclose(b, rel_tol=1e-12, abs_tol=0.2)
assert not a.isclose(b, rel_tol=1e-12, abs_tol=0.05)
assert b.isclose(a, rel_tol=1e-12, abs_tol=0.2)
assert not b.isclose(a, rel_tol=1e-12, abs_tol=0.05)
def test_isclose_rel_tol():
a = QubitOperator('X0', 1)
b = QubitOperator('X0', 2)
assert a.isclose(b, rel_tol=2.5, abs_tol=0.1)
# Test symmetry
assert a.isclose(b, rel_tol=1, abs_tol=0.1)
assert b.isclose(a, rel_tol=1, abs_tol=0.1)
def test_mul_out_of_place():
op1 = QubitOperator(((0, 'Y'), (3, 'X'), (8, 'Z'), (11, 'X')), 3.j)
op2 = QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5)
op3 = op1 * op2
correct_coefficient = 1.j * 3.0j * 0.5
correct_term = ((0, 'Y'), (1, 'X'), (3, 'Z'), (11, 'X'))
assert op1.isclose(QubitOperator(
((0, 'Y'), (3, 'X'), (8, 'Z'), (11, 'X')), 3.j))
assert op2.isclose(QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5))
assert op3.isclose(QubitOperator(correct_term, correct_coefficient))
def test_isclose_abs_tol():
a = QubitOperator('X0', -1.)
b = QubitOperator('X0', -1.05)
c = QubitOperator('X0', -1.11)
assert a.isclose(b, rel_tol=1e-14, abs_tol=0.1)
assert not a.isclose(c, rel_tol=1e-14, abs_tol=0.1)
a = QubitOperator('X0', -1.0j)
b = QubitOperator('X0', -1.05j)
c = QubitOperator('X0', -1.11j)
assert a.isclose(b, rel_tol=1e-14, abs_tol=0.1)
assert not a.isclose(c, rel_tol=1e-14, abs_tol=0.1)
def test_add():
term_a = ((1, 'X'), (3, 'Y'), (8, 'Z'))
term_b = ((1, 'Z'), (3, 'Y'), (8, 'Z'))
a = QubitOperator(term_a, 1.0)
b = QubitOperator(term_b, 0.5)
res = a + b + b
assert len(res.terms) == 2
assert res.terms[term_a] == pytest.approx(1.0)
assert res.terms[term_b] == pytest.approx(1.0)
# Test out of place
assert a.isclose(QubitOperator(term_a, 1.0))
assert b.isclose(QubitOperator(term_b, 0.5))
def test_itruediv_and_idiv(divisor):
op = QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5)
op2 = copy.deepcopy(op)
original = copy.deepcopy(op)
correct = op * (1. / divisor)
op /= divisor
op2.__idiv__(divisor) # To test python 2 version as well
assert op.isclose(correct)
assert op2.isclose(correct)
# Test if done in-place
assert not op.isclose(original)
assert not op2.isclose(original)
def test_neg():
op = QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5)
-op
# out of place
assert op.isclose(QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5))
correct = -1.0 * op
assert correct.isclose(-op)
def test_truediv_and_div(divisor):
op = QubitOperator(((1, 'X'), (3, 'Y'), (8, 'Z')), 0.5)
op2 = copy.deepcopy(op)
original = copy.deepcopy(op)
res = op / divisor
res2 = op2.__div__(divisor) # To test python 2 version as well
correct = op * (1. / divisor)
assert res.isclose(correct)
assert res2.isclose(correct)
# Test if done out of place
assert op.isclose(original)
assert op2.isclose(original)
def test_isclose_zero_terms():
op = QubitOperator(((1, 'Y'), (0, 'X')), -1j) * 0
assert op.isclose(QubitOperator((), 0.0), rel_tol=1e-12, abs_tol=1e-12)
assert QubitOperator((), 0.0).isclose(op, rel_tol=1e-12, abs_tol=1e-12)
