def test_multiplication(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r * c(2, "dn"), ExpressionR)
self.assertIsInstance(c(2, "dn") * expr_r, ExpressionR)
self.assertEqual(str(ExpressionR() * ExpressionR()), "0")
self.assertEqual(str(expr_r * ExpressionR()), "0")
self.assertEqual(str(ExpressionR() * expr_r), "0")
self.assertEqual(str(expr_r * c(2, "dn")), "1*C+(1,up)C(2,dn)")
self.assertEqual(str(c(2, "dn") * expr_r), "-1*C+(1,up)C(2,dn)")
expr_r *= c(2, "dn")
self.assertEqual(str(expr_r * a(0, "x")), "1*C+(1,up)C(2,dn)A(0,x)")
self.assertEqual(str(a(0, "x") * expr_r), "1*C+(1,up)C(2,dn)A(0,x)")
self.assertEqual(str(expr_r * c_dag(1, "up")), "0")
self.assertEqual(str(c_dag(1, "up") * expr_r), "0")
# Real and complex
expr1 = make_complex(c_dag(1, "up"))
expr2 = c(2, "dn")
self.assertIsInstance(expr1 * expr2, ExpressionC)
self.assertIsInstance(expr2 * expr1, ExpressionC)
self.assertEqual(str(ExpressionC() * ExpressionR()), "(0,0)")
self.assertEqual(str(ExpressionR() * ExpressionC()), "(0,0)")
self.assertEqual(str(expr1 * ExpressionR()), "(0,0)")
self.assertEqual(str(ExpressionR() * expr1), "(0,0)")
self.assertEqual(str(expr2 * ExpressionC()), "(0,0)")
self.assertEqual(str(ExpressionC() * expr2), "(0,0)")
self.assertEqual(str(expr1 * expr2), "(1,0)*C+(1,up)C(2,dn)")
self.assertEqual(str(expr2 * expr1), "(-1,0)*C+(1,up)C(2,dn)")
expr1 *= expr2
self.assertEqual(str(expr1 * a(0, "x")), "(1,0)*C+(1,up)C(2,dn)A(0,x)")
self.assertEqual(str(a(0, "x") * expr1), "(1,0)*C+(1,up)C(2,dn)A(0,x)")
self.assertEqual(str(expr1 * make_complex(c_dag(1, "up"))), "(0,0)")
self.assertEqual(str(make_complex(c_dag(1, "up")) * expr1), "(0,0)")
def test_inplace_multiplication(self):
# Real
expr_r = c(2, "dn")
expr_r *= c_dag(1, "up")
self.assertEqual(str(expr_r), "-1*C+(1,up)C(2,dn)")
expr_r *= a(0, "x")
self.assertEqual(str(expr_r), "-1*C+(1,up)C(2,dn)A(0,x)")
expr_r *= a_dag(0, "y")
self.assertEqual(str(expr_r), "-1*C+(1,up)C(2,dn)A+(0,y)A(0,x)")
expr_r *= ExpressionR(2)
self.assertEqual(str(expr_r), "-2*C+(1,up)C(2,dn)A+(0,y)A(0,x)")
expr_r *= ExpressionR()
self.assertEqual(str(expr_r), "0")
# Complex
expr_c = make_complex(c(2, "dn"))
expr_c *= make_complex(c_dag(1, "up"))
self.assertEqual(str(expr_c), "(-1,0)*C+(1,up)C(2,dn)")
expr_c *= make_complex(a(0, "x"))
self.assertEqual(str(expr_c), "(-1,0)*C+(1,up)C(2,dn)A(0,x)")
expr_c *= make_complex(a_dag(0, "y"))
self.assertEqual(str(expr_c), "(-1,0)*C+(1,up)C(2,dn)A+(0,y)A(0,x)")
expr_c *= ExpressionC(2)
self.assertEqual(str(expr_c), "(-2,0)*C+(1,up)C(2,dn)A+(0,y)A(0,x)")
expr_c *= ExpressionC()
self.assertEqual(str(expr_c), "(0,0)")
def test_subtraction(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r - c(2, "dn"), ExpressionR)
self.assertIsInstance(c(2, "dn") - expr_r, ExpressionR)
self.assertEqual(str(ExpressionR() - ExpressionR()), "0")
self.assertEqual(str(expr_r - ExpressionR()), "1*C+(1,up)")
self.assertEqual(str(ExpressionR() - expr_r), "-1*C+(1,up)")
self.assertEqual(str(expr_r - c(2, "dn")), "1*C+(1,up) + -1*C(2,dn)")
self.assertEqual(str(c(2, "dn") - expr_r), "-1*C+(1,up) + 1*C(2,dn)")
expr_r -= c(2, "dn")
self.assertEqual(str(expr_r + ExpressionR()),
"1*C+(1,up) + -1*C(2,dn)")
self.assertEqual(str(ExpressionR() - expr_r),
"-1*C+(1,up) + 1*C(2,dn)")
self.assertEqual(str(expr_r - a(0, "x")),
"1*C+(1,up) + -1*C(2,dn) + -1*A(0,x)")
self.assertEqual(str(a(0, "x") - expr_r),
"-1*C+(1,up) + 1*C(2,dn) + 1*A(0,x)")
self.assertEqual(str(expr_r - c_dag(1, "up")), "-1*C(2,dn)")
self.assertEqual(str(c_dag(1, "up") - expr_r), "1*C(2,dn)")
self.assertEqual(
str((c_dag(1, "up") + c(2, "dn")) - (c(2, "dn") + 2.0)),
"-2 + 1*C+(1,up)")
# Real and complex
expr1 = make_complex(c_dag(1, "up"))
expr2 = c(2, "dn")
self.assertIsInstance(expr1 - expr2, ExpressionC)
self.assertIsInstance(expr2 - expr1, ExpressionC)
self.assertEqual(str(ExpressionC() - ExpressionR()), "(0,0)")
self.assertEqual(str(ExpressionR() - ExpressionC()), "(0,0)")
self.assertEqual(str(expr1 - ExpressionR()), "(1,0)*C+(1,up)")
self.assertEqual(str(ExpressionR() - expr1), "(-1,-0)*C+(1,up)")
self.assertEqual(str(expr2 - ExpressionC()), "(1,-0)*C(2,dn)")
self.assertEqual(str(ExpressionC() - expr2), "(-1,0)*C(2,dn)")
self.assertEqual(str(expr1 - expr2), "(1,0)*C+(1,up) + (-1,0)*C(2,dn)")
self.assertEqual(str(expr2 - expr1),
"(-1,-0)*C+(1,up) + (1,-0)*C(2,dn)")
expr1 -= expr2
self.assertEqual(str(expr1 - ExpressionR()),
"(1,0)*C+(1,up) + (-1,0)*C(2,dn)")
self.assertEqual(str(ExpressionR() - expr1),
"(-1,-0)*C+(1,up) + (1,-0)*C(2,dn)")
self.assertEqual(str(expr1 - a(0, "x")),
"(1,0)*C+(1,up) + (-1,0)*C(2,dn) + (-1,0)*A(0,x)")
self.assertEqual(str(a(0, "x") - expr1),
"(-1,-0)*C+(1,up) + (1,-0)*C(2,dn) + (1,-0)*A(0,x)")
self.assertEqual(str(expr1 - make_complex(c_dag(1, "up"))),
"(-1,0)*C(2,dn)")
self.assertEqual(str(make_complex(c_dag(1, "up")) - expr1),
"(1,0)*C(2,dn)")
self.assertEqual(
str(
make_complex(c_dag(1, "up") + c(2, "dn")) -
(c(2, "dn") + 2.0)), "(-2,0) + (1,0)*C+(1,up)")
def test_addition(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r + c(2, "dn"), ExpressionR)
self.assertIsInstance(c(2, "dn") + expr_r, ExpressionR)
self.assertEqual(str(ExpressionR() + ExpressionR()), "0")
self.assertEqual(str(expr_r + ExpressionR()), "1*C+(1,up)")
self.assertEqual(str(ExpressionR() + expr_r), "1*C+(1,up)")
self.assertEqual(str(expr_r + c(2, "dn")), "1*C+(1,up) + 1*C(2,dn)")
self.assertEqual(str(c(2, "dn") + expr_r), "1*C+(1,up) + 1*C(2,dn)")
expr_r += c(2, "dn")
self.assertEqual(str(expr_r + ExpressionR()), "1*C+(1,up) + 1*C(2,dn)")
self.assertEqual(str(ExpressionR() + expr_r), "1*C+(1,up) + 1*C(2,dn)")
self.assertEqual(str(expr_r + a(0, "x")),
"1*C+(1,up) + 1*C(2,dn) + 1*A(0,x)")
self.assertEqual(str(a(0, "x") + expr_r),
"1*C+(1,up) + 1*C(2,dn) + 1*A(0,x)")
self.assertEqual(str(expr_r + (-c_dag(1, "up"))), "1*C(2,dn)")
self.assertEqual(str((-c_dag(1, "up")) + expr_r), "1*C(2,dn)")
self.assertEqual(
str((c_dag(1, "up") + c(2, "dn")) + (c(2, "dn") + 2.0)),
"2 + 1*C+(1,up) + 2*C(2,dn)")
# Real and complex
expr1 = make_complex(c_dag(1, "up"))
expr2 = c(2, "dn")
self.assertIsInstance(expr1 + expr2, ExpressionC)
self.assertIsInstance(expr2 + expr1, ExpressionC)
self.assertEqual(str(ExpressionC() + ExpressionR()), "(0,0)")
self.assertEqual(str(ExpressionR() + ExpressionC()), "(0,0)")
self.assertEqual(str(expr1 + ExpressionR()), "(1,0)*C+(1,up)")
self.assertEqual(str(ExpressionR() + expr1), "(1,0)*C+(1,up)")
self.assertEqual(str(expr2 + ExpressionC()), "(1,0)*C(2,dn)")
self.assertEqual(str(ExpressionC() + expr2), "(1,0)*C(2,dn)")
self.assertEqual(str(expr1 + expr2), "(1,0)*C+(1,up) + (1,0)*C(2,dn)")
self.assertEqual(str(expr2 + expr1), "(1,0)*C+(1,up) + (1,0)*C(2,dn)")
expr1 += expr2
self.assertEqual(str(expr1 + ExpressionR()),
"(1,0)*C+(1,up) + (1,0)*C(2,dn)")
self.assertEqual(str(ExpressionR() + expr1),
"(1,0)*C+(1,up) + (1,0)*C(2,dn)")
self.assertEqual(str(expr1 + a(0, "x")),
"(1,0)*C+(1,up) + (1,0)*C(2,dn) + (1,0)*A(0,x)")
self.assertEqual(str(a(0, "x") + expr1),
"(1,0)*C+(1,up) + (1,0)*C(2,dn) + (1,0)*A(0,x)")
self.assertEqual(str(expr1 + (-make_complex(c_dag(1, "up")))),
"(1,0)*C(2,dn)")
self.assertEqual(str((-make_complex(c_dag(1, "up"))) + expr1),
"(1,0)*C(2,dn)")
self.assertEqual(
str(
make_complex(c_dag(1, "up") + c(2, "dn")) +
(c(2, "dn") + 2.0)), "(2,0) + (1,0)*C+(1,up) + (2,0)*C(2,dn)")
def test_multiplication_const(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r * 2, ExpressionR)
self.assertIsInstance(2 * expr_r, ExpressionR)
self.assertEqual(str(expr_r * 0), "0")
self.assertEqual(str(0 * expr_r), "0")
self.assertEqual(str(expr_r * 2), "2*C+(1,up)")
self.assertEqual(str(2 * expr_r), "2*C+(1,up)")
# Complex and real
expr_c = make_complex(c_dag(1, "up"))
self.assertIsInstance(expr_c * 2.0, ExpressionC)
self.assertIsInstance(2.0 * expr_c, ExpressionC)
self.assertEqual(str(expr_c * 0.0), "(0,0)")
self.assertEqual(str(0.0 * expr_c), "(0,0)")
self.assertEqual(str(expr_c * 2.0), "(2,0)*C+(1,up)")
self.assertEqual(str(2.0 * expr_c), "(2,0)*C+(1,up)")
# Real and complex
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r * 2.0j, ExpressionC)
self.assertIsInstance(2.0j * expr_r, ExpressionC)
self.assertEqual(str(expr_r * 0.0j), "(0,0)")
self.assertEqual(str(0.0j * expr_r), "(0,0)")
self.assertEqual(str(expr_r * 2.0j), "(0,2)*C+(1,up)")
self.assertEqual(str(2.0j * expr_r), "(0,2)*C+(1,up)")
def check_monomial(self, expr, ref_coeff, *generators):
ref_monomial = Monomial(list(generators))
# Real
self.assertEqual(len(expr), 1)
self.assertEqual(*iter(expr), (ref_monomial, ref_coeff))
# Complex
expr_c = make_complex(expr)
self.assertEqual(len(expr_c), 1)
self.assertEqual(*iter(expr_c), (ref_monomial, complex(ref_coeff)))
def test_LOperatorC(self):
expr1 = make_complex(3 * c_dag("dn"))
expr2 = make_complex(3 * c("up"))
expr = 2j * expr1 - 2j * expr2
hs = HilbertSpace(expr)
lop1 = LOperatorC(expr1, hs)
lop2 = LOperatorC(expr2, hs)
lop = LOperatorC(expr, hs)
src = np.array([1, 1, 1, 1])
dst = np.zeros((4, ), dtype=complex)
assert_equal(lop1 * src, np.array([0, 3, 0, 3], dtype=complex))
lop1(src, dst)
assert_equal(dst, np.array([0, 3, 0, 3], dtype=complex))
assert_equal(lop2 * src, np.array([3, -3, 0, 0], dtype=complex))
lop2(src, dst)
assert_equal(dst, np.array([3, -3, 0, 0], dtype=complex))
assert_equal(lop * src, np.array([-6j, 12j, 0, 6j]))
lop(src, dst)
assert_equal(dst, np.array([-6j, 12j, 0, 6j]))
src_complex = 1j * np.array([1, 1, 1, 1])
assert_equal(lop * src_complex, np.array([6, -12, 0, -6]))
lop(src_complex, dst)
assert_equal(dst, np.array([6, -12, 0, -6]))
with self.assertRaisesRegex(
RuntimeError, "^State vector must be a 1-dimensional array$"):
lop * np.zeros((3, 3, 3))
with self.assertRaisesRegex(
RuntimeError,
"^Source state vector must be a 1-dimensional array$"):
lop(np.zeros((3, 3, 3)), np.zeros((5, ), dtype=complex))
with self.assertRaisesRegex(
RuntimeError,
"^Destination state vector must be a 1-dimensional array$"):
lop(np.zeros((5, )), np.zeros((3, 3, 3), dtype=complex))
def test_inplace_multiplication_const(self):
# Real
expr_r = c_dag(1, "up")
expr_r *= 4.0
self.assertEqual(str(expr_r), "4*C+(1,up)")
expr_r *= 0.0
self.assertEqual(str(expr_r), "0")
# Real and complex
expr_c = make_complex(c_dag(1, "up"))
expr_c *= 4.0
self.assertEqual(str(expr_c), "(4,0)*C+(1,up)")
expr_c *= 0.0
self.assertEqual(str(expr_c), "(0,0)")
def test_inplace_subtraction_const(self):
# Real
expr_r = c_dag(1, "up")
expr_r -= 4.0
self.assertEqual(str(expr_r), "-4 + 1*C+(1,up)")
expr_r -= 0.0
self.assertEqual(str(expr_r), "-4 + 1*C+(1,up)")
expr_r -= -4.0
self.assertEqual(str(expr_r), "1*C+(1,up)")
# Real and complex
expr_c = make_complex(c_dag(1, "up"))
expr_c -= 4.0
self.assertEqual(str(expr_c), "(-4,0) + (1,0)*C+(1,up)")
expr_c -= 0.0
self.assertEqual(str(expr_c), "(-4,0) + (1,0)*C+(1,up)")
expr_c -= -4.0
self.assertEqual(str(expr_c), "(1,0)*C+(1,up)")
def test_inplace_subtraction(self):
# Real
expr_r = c_dag(1, "up")
expr_r -= c(2, "dn")
self.assertEqual(str(expr_r), "1*C+(1,up) + -1*C(2,dn)")
expr_r -= ExpressionR()
self.assertEqual(str(expr_r), "1*C+(1,up) + -1*C(2,dn)")
expr_r -= c_dag(1, "up")
self.assertEqual(str(expr_r), "-1*C(2,dn)")
# Complex
expr_c = make_complex(c_dag(1, "up"))
expr_c -= c(2, "dn")
self.assertEqual(str(expr_c), "(1,0)*C+(1,up) + (-1,0)*C(2,dn)")
expr_c -= ExpressionC()
self.assertEqual(str(expr_c), "(1,0)*C+(1,up) + (-1,0)*C(2,dn)")
expr_c -= c_dag(1, "up")
self.assertEqual(str(expr_c), "(-1,0)*C(2,dn)")
def test_subtraction_const(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r - 2, ExpressionR)
self.assertIsInstance(2 - expr_r, ExpressionR)
self.assertEqual(str(expr_r - 0), "1*C+(1,up)")
self.assertEqual(str(0 - expr_r), "-1*C+(1,up)")
self.assertEqual(str(expr_r - 2), "-2 + 1*C+(1,up)")
self.assertEqual(str(2 - expr_r), "2 + -1*C+(1,up)")
expr_r -= 2.0
self.assertEqual(str(expr_r - 0), "-2 + 1*C+(1,up)")
self.assertEqual(str(0 - expr_r), "2 + -1*C+(1,up)")
self.assertEqual(str(expr_r - 2), "-4 + 1*C+(1,up)")
self.assertEqual(str(2 - expr_r), "4 + -1*C+(1,up)")
self.assertEqual(str(expr_r - (-2)), "1*C+(1,up)")
self.assertEqual(str((-2) - expr_r), "-1*C+(1,up)")
# Complex and real
expr_c = make_complex(c_dag(1, "up"))
self.assertIsInstance(expr_c - 2.0, ExpressionC)
self.assertIsInstance(2.0 - expr_c, ExpressionC)
self.assertEqual(str(expr_c - 0.0), "(1,0)*C+(1,up)")
self.assertEqual(str(0.0 - expr_c), "(-1,-0)*C+(1,up)")
self.assertEqual(str(expr_c - 2.0), "(-2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0 - expr_c), "(2,0) + (-1,-0)*C+(1,up)")
expr_c -= 2.0
self.assertEqual(str(expr_c - 0.0), "(-2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(0.0 - expr_c), "(2,-0) + (-1,-0)*C+(1,up)")
self.assertEqual(str(expr_c - 2.0), "(-4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0 - expr_c), "(4,-0) + (-1,-0)*C+(1,up)")
self.assertEqual(str(expr_c - (-2.0)), "(1,0)*C+(1,up)")
self.assertEqual(str((-2.0) - expr_c), "(-1,-0)*C+(1,up)")
# Real and complex
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r - 2j, ExpressionC)
self.assertIsInstance(2j - expr_r, ExpressionC)
self.assertEqual(str(expr_r - 0.0j), "(1,0)*C+(1,up)")
self.assertEqual(str(0.0j - expr_r), "(-1,0)*C+(1,up)")
self.assertEqual(str(expr_r - 2.0j), "(0,-2) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0j - expr_r), "(0,2) + (-1,0)*C+(1,up)")
expr_r -= 2.0
self.assertEqual(str(expr_r - 0.0j), "(-2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(0.0j - expr_r), "(2,0) + (-1,0)*C+(1,up)")
self.assertEqual(str(expr_r - 2.0 + 0j), "(-4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0 + 0j - expr_r), "(4,0) + (-1,0)*C+(1,up)")
self.assertEqual(str(expr_r - (-2.0 + 0j)), "(1,0)*C+(1,up)")
self.assertEqual(str((-2.0 + 0j) - expr_r), "(-1,0)*C+(1,up)")
def test_inplace_addition(self):
# Real
expr_r = c_dag(1, "up")
expr_r += c(2, "dn")
self.assertEqual(str(expr_r), "1*C+(1,up) + 1*C(2,dn)")
expr_r += ExpressionR()
self.assertEqual(str(expr_r), "1*C+(1,up) + 1*C(2,dn)")
expr_r += -c_dag(1, "up")
self.assertEqual(str(expr_r), "1*C(2,dn)")
# Complex
expr_c = make_complex(c_dag(1, "up"))
expr_c += c(2, "dn")
self.assertEqual(str(expr_c), "(1,0)*C+(1,up) + (1,0)*C(2,dn)")
expr_c += ExpressionC()
self.assertEqual(str(expr_c), "(1,0)*C+(1,up) + (1,0)*C(2,dn)")
expr_c += -c_dag(1, "up")
self.assertEqual(str(expr_c), "(1,0)*C(2,dn)")
def test_addition_const(self):
# Real
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r + 2, ExpressionR)
self.assertIsInstance(2 + expr_r, ExpressionR)
self.assertEqual(str(expr_r + 0), "1*C+(1,up)")
self.assertEqual(str(0 + expr_r), "1*C+(1,up)")
self.assertEqual(str(expr_r + 2), "2 + 1*C+(1,up)")
self.assertEqual(str(2 + expr_r), "2 + 1*C+(1,up)")
expr_r += 2.0
self.assertEqual(str(expr_r + 0), "2 + 1*C+(1,up)")
self.assertEqual(str(0 + expr_r), "2 + 1*C+(1,up)")
self.assertEqual(str(expr_r + 2), "4 + 1*C+(1,up)")
self.assertEqual(str(2 + expr_r), "4 + 1*C+(1,up)")
self.assertEqual(str(expr_r + (-2)), "1*C+(1,up)")
self.assertEqual(str((-2) + expr_r), "1*C+(1,up)")
# Complex and real
expr_c = make_complex(c_dag(1, "up"))
self.assertIsInstance(expr_c + 2.0, ExpressionC)
self.assertIsInstance(2.0 + expr_c, ExpressionC)
self.assertEqual(str(expr_c + 0.0), "(1,0)*C+(1,up)")
self.assertEqual(str(0.0 + expr_c), "(1,0)*C+(1,up)")
self.assertEqual(str(expr_c + 2.0), "(2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0 + expr_c), "(2,0) + (1,0)*C+(1,up)")
expr_c += 2.0
self.assertEqual(str(expr_c + 0.0), "(2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(0.0 + expr_c), "(2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(expr_c + 2.0), "(4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0 + expr_c), "(4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(expr_c + (-2.0)), "(1,0)*C+(1,up)")
self.assertEqual(str((-2.0) + expr_c), "(1,0)*C+(1,up)")
# Real and complex
expr_r = c_dag(1, "up")
self.assertIsInstance(expr_r + 2.0j, ExpressionC)
self.assertIsInstance(2.0j + expr_r, ExpressionC)
self.assertEqual(str(expr_r + 0.0j), "(1,0)*C+(1,up)")
self.assertEqual(str(0.0j + expr_r), "(1,0)*C+(1,up)")
self.assertEqual(str(expr_r + 2.0j), "(0,2) + (1,0)*C+(1,up)")
self.assertEqual(str(2.0j + expr_r), "(0,2) + (1,0)*C+(1,up)")
expr_r += 2.0
self.assertEqual(str(expr_r + 0.0j), "(2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(0.0j + expr_r), "(2,0) + (1,0)*C+(1,up)")
self.assertEqual(str(expr_r + 2 + 0j), "(4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(2 + 0j + expr_r), "(4,0) + (1,0)*C+(1,up)")
self.assertEqual(str(expr_r + (-2 + 0j)), "(1,0)*C+(1,up)")
self.assertEqual(str((-2 + 0j) + expr_r), "(1,0)*C+(1,up)")
def test_inplace_addition_const(self):
# Real
expr_r = c_dag(1, "up")
expr_r += 4.0
self.assertEqual(str(expr_r), "4 + 1*C+(1,up)")
expr_r += 0.0
self.assertEqual(str(expr_r), "4 + 1*C+(1,up)")
expr_r += -4.0
self.assertEqual(str(expr_r), "1*C+(1,up)")
# Real and complex
expr_c = make_complex(c_dag(1, "up"))
expr_c += 4.0
self.assertEqual(str(expr_c), "(4,0) + (1,0)*C+(1,up)")
expr_c += 0.0
self.assertEqual(str(expr_c), "(4,0) + (1,0)*C+(1,up)")
expr_c += -4.0
self.assertEqual(str(expr_c), "(1,0)*C+(1,up)")
def test_loperator(self):
M = 5
hs = HilbertSpace([make_space_boson(2, 0)])
for i in range(M):
hs.add(make_space_fermion(i))
H = (n(0) + n(1) + n(2) + n(3) + n(4)) * (a_dag(0) + a(0))
for src_type, dst_type, lop_type in [(float, float, LOperatorR),
(float, complex, LOperatorR),
(complex, complex, LOperatorR),
(float, complex, LOperatorC),
(complex, complex, LOperatorC)]:
src_view_type = NFermionSectorViewR if (src_type == float) \
else NFermionSectorViewC
dst_view_type = NFermionSectorViewR if (dst_type == float) \
else NFermionSectorViewC
Hop = lop_type(H if lop_type == LOperatorR else make_complex(H),
hs)
for N in range(M + 1):
src = np.zeros(n_fermion_sector_size(hs, N), dtype=src_type)
view_src = src_view_type(src, hs, N)
dst = np.zeros(n_fermion_sector_size(hs, N), dtype=dst_type)
view_dst = dst_view_type(dst, hs, N)
# 1 boson, fermions in the first N modes
index_in_f = sum(2**i for i in range(N))
src[view_src.map_index(index_in_f + (2**M))] = 1
Hop(view_src, view_dst)
ref = np.zeros(n_fermion_sector_size(hs, N), dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (M + 1)))] = \
N * np.sqrt(2)
assert_allclose(dst, ref)
def test_complex_only(self):
# Spin 1/2
self.assertEqual(make_complex(S_p(0, "x")),
S_x(0, "x") + 1j * S_y(0, "x"))
self.assertEqual(make_complex(S_m(0, "x")),
S_x(0, "x") - 1j * S_y(0, "x"))
# Spin 1
self.assertEqual(make_complex(S_p(0, "x", spin=1)),
S_x(0, "x", spin=1) + 1j * S_y(0, "x", spin=1))
self.assertEqual(make_complex(S_m(0, "x", spin=1)),
S_x(0, "x", spin=1) - 1j * S_y(0, "x", spin=1))
# Spin 3/2
self.assertEqual(
make_complex(S_p(0, "x", spin=3 / 2)),
S_x(0, "x", spin=3 / 2) + 1j * S_y(0, "x", spin=3 / 2))
self.assertEqual(
make_complex(S_m(0, "x", spin=3 / 2)),
S_x(0, "x", spin=3 / 2) - 1j * S_y(0, "x", spin=3 / 2))
def test_loperator(self):
hs = HilbertSpace([make_space_boson(2, 0)])
for i in range(self.M_total):
hs.add(make_space_fermion(i))
sector_a_modes = [1, 2, 6, 7]
sector_b_modes = [3, 4, 8, 9]
Ha = (n(1) + n(2) + n(6) + n(7)) * (a_dag(0) + a(0))
Hb = (n(3) + n(4) + n(8) + n(9)) * (a_dag(0) + a(0))
for src_type, dst_type, lop_type in [(float, float, LOperatorR),
(float, complex, LOperatorR),
(complex, complex, LOperatorR),
(float, complex, LOperatorC),
(complex, complex, LOperatorC)]:
src_view_type = NFermionMultiSectorViewR if (src_type == float) \
else NFermionMultiSectorViewC
dst_view_type = NFermionMultiSectorViewR if (dst_type == float) \
else NFermionMultiSectorViewC
lop_is_real = lop_type == LOperatorR
Hopa = lop_type(Ha if lop_is_real else make_complex(Ha), hs)
Hopb = lop_type(Hb if lop_is_real else make_complex(Hb), hs)
for N1, N2 in product(range(self.Na_max + 1),
range(self.Nb_max + 1)):
sectors = [self.sda(N1), self.sdb(N2)]
src = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=src_type)
view_src = src_view_type(src, hs, sectors)
dst = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
view_dst = dst_view_type(dst, hs, sectors)
# Input:
# First N1 modes of sector A are occupied
# First N2 modes of sector B are occupied
# 1 boson
index_in_f = sum(2**sector_a_modes[n1] for n1 in range(N1))
index_in_f += sum(2**sector_b_modes[n2] for n2 in range(N2))
src[view_src.map_index(index_in_f + (2**self.M_total))] = 1
Hopa(view_src, view_dst)
ref = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N1
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (self.M_total + 1)))]\
= N1 * np.sqrt(2)
assert_allclose(dst, ref)
Hopb(view_src, view_dst)
ref = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N2
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (self.M_total + 1)))]\
= N2 * np.sqrt(2)
assert_allclose(dst, ref)
def test_make_complex(self):
expr = make_complex(4.0 * c_dag(1, "up") * c(2, "dn") + 1.0)
self.assertEqual(expr, (4 + 0j) * c_dag(1, "up") * c(2, "dn") + 1 + 0j)