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)