def test_jet_extend_basis1(self): x1, x2, x3 = xx = st.symb_vector("x1, x2, x3") xx_tmp, ddx = pc.setup_objects(xx) self.assertTrue(xx is xx_tmp) # get the individual forms dx1, dx2, dx3 = ddx dx1.jet_extend_basis() xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx) xddot1, xddot2, xddot3 = xxdd = pc.st.time_deriv(xx, xx, order=2) full_basis = st.row_stack(xx, xxd, xxdd) foo, ddX = pc.setup_objects(full_basis) dx1.jet_extend_basis() self.assertEqual(ddX[0].basis, dx1.basis) self.assertEqual(ddX[0].coeff, dx1.coeff) half_basis = st.row_stack(xx, xxd) foo, ddY = pc.setup_objects(half_basis) dx2.jet_extend_basis() self.assertEqual(ddY[1].basis, dx2.basis) self.assertEqual(ddY[1].coeff, dx2.coeff)
def test_get_baseform_from_plain_index(self): x1, x2, x3 = xx = st.symb_vector("x1, x2, x3") xx, dxx = pc.setup_objects(xx) dx1, dx2, dx3 = dxx W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3) res = W.get_baseform_from_plain_index(0) self.assertEqual(res, dx1 ^ dx2) res = W.get_baseform_from_plain_index(2) self.assertEqual(res, dx2 ^ dx3) res = W.get_baseform_from_plain_index(-1) self.assertEqual(res, dx2 ^ dx3) res = W.get_baseform_from_plain_index(-2) self.assertEqual(res, dx1 ^ dx3) res = W.get_baseform_from_plain_index(-3) self.assertEqual(res, dx1 ^ dx2) with self.assertRaises(ValueError) as cm: res = W.get_baseform_from_plain_index(3) with self.assertRaises(ValueError) as cm: res = W.get_baseform_from_plain_index(-4)
def test_get_baseform(self): x1, x2, x3 = xx = st.symb_vector("x1, x2, x3") xx, dxx = pc.setup_objects(xx) dx1, dx2, dx3 = dxx W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3) res1 = W.get_baseform_from_idcs((0, 1)) self.assertEqual(res1, dx1 ^ dx2) idcs_matrix = sp.Matrix([0, 2]) res2 = W.get_baseform_from_idcs(idcs_matrix) self.assertEqual(res2, dx1 ^ dx3) idcs_array = st.np.array([0, 2]) res2b = W.get_baseform_from_idcs(idcs_array) self.assertEqual(res2b, dx1 ^ dx3) res3 = W.get_baseform_from_idcs((1, 2)) self.assertEqual(res3, dx2 ^ dx3) Z = dx1 + x3**2 * dx2 res4 = Z.get_baseform_from_idcs((1, )) self.assertEqual(res4, dx2) res5 = Z.get_baseform_from_idcs(2) self.assertEqual(res5, dx3) with self.assertRaises(TypeError) as cm: res = W.get_baseform_from_idcs(dx1) with self.assertRaises(ValueError) as cm: res = W.get_baseform_from_idcs((0, 0))
def test_ord(self): x1, x2, x3 = xx = st.symb_vector("x1, x2, x3") xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx) xxdd = pc.st.time_deriv(xx, xx, order=2) XX = st.concat_rows(xx, xxd, xxdd) XX, dXX = pc.setup_objects(XX) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = dXX w0 = 0 * dx1 w1 = dx1 + dxdot3 w2 = 4 * x2 * dx1 - sp.sin(x3) * xdot1 * dx2 self.assertEqual(w0.ord, 0) self.assertEqual(dx1.ord, 0) self.assertEqual(dxdot1.ord, 1) self.assertEqual(dxddot3.ord, 2) self.assertEqual(w1.ord, 1) self.assertEqual(w2.ord, 0) self.assertEqual(w2.d.ord, 1) w3 = w1 ^ w2 self.assertEqual(w3.ord, 1) self.assertEqual(w3.dot().ord, 2)
def test_jet_extend_basis1(self): x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3")) xx_tmp, ddx = pc.setup_objects(xx) self.assertTrue(xx is xx_tmp) # get the individual forms dx1, dx2, dx3 = ddx dx1.jet_extend_basis() self.assertTrue(len(dx1.basis) == 2 * len(xx)) self.assertTrue(dx1.coeff[0] == 1) self.assertFalse(any(dx1.coeff[1:])) # derivative coordinates xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx) ext_basis = pc.st.row_stack(xx, xxd) w1 = xdot1 * dx2 w1.jet_extend_basis() self.assertEqual(w1.basis[3], w1.coeff[1]) dw1 = w1.d res1 = pc.d(xdot1, ext_basis) ^ pc.d(x2, ext_basis) self.assertEqual(dw1, res1) w2 = x3 * dx2 self.assertEqual(w2.dim_basis, len(xx)) w2.jet_extend_basis() self.assertEqual(w2.dim_basis, len(ext_basis)) dw2 = w2.d res2 = -dx2 ^ dx3 res2.jet_extend_basis() self.assertEqual(dw2, res2)
def test_get_coeff(self): xx = st.symb_vector("x, y, z") (x, y, z), (dx, dy, dz) = pc.setup_objects(xx) w = 7 * dx - x**2 * dy c1 = w.get_coeff(dx) c2 = w.get_coeff(dy) self.assertEqual(c1, 7) self.assertEqual(c2, -x**2)
def test_hodge_star_3d(self): x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3")) foo, ddx = pc.setup_objects(xx) dx1, dx2, dx3 = ddx # cross product is hodge dual of wedge product self.assertEqual((dx1 ^ dx2).hodge_star(), dx3) self.assertEqual((dx1 ^ dx3).hodge_star(), -dx2) self.assertEqual((dx2 ^ dx3).hodge_star(), dx1) # https://en.wikipedia.org/wiki/Hodge_isomorphism#Three_dimensions self.assertEqual(dx1.hodge_star(), dx2 ^ dx3) self.assertEqual(dx2.hodge_star(), dx3 ^ dx1) # note the non canonical order self.assertEqual(dx3.hodge_star(), dx1 ^ dx2)
def test_dot3(self): xx = sp.Matrix(sp.symbols("x1, x2, x3")) xxd = pc.st.time_deriv(xx, xx) xxdd = pc.st.time_deriv(xx, xx, order=2) full_basis = pc.st.row_stack(xx, xxd, xxdd) foo, ddx = pc.setup_objects(full_basis) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx aa = sp.Matrix(sp.symbols("a1:3")) a1, a2 = aa mu1 = a1 * dxdot1 + 3 * a2 * dx2 mu1.dot() # this once was a bug: self.assertEqual(xxdd[0].difforder, 2)
def test_hodge_star_4d(self): # noinspection PyPep8Naming x1, x2, x3, x4 = xx = sp.Matrix(sp.symbols("x1, x2, x3, x4")) foo, ddx = pc.setup_objects(xx) dt, dx, dy, dz = ddx # see https://en.wikipedia.org/wiki/Hodge_isomorphism#Four_dimensions # Minkowski spacetime with metric signature (+ − − −) # Currently not supported (non-standard scalar product not yet implemented) self.assertEqual(dt.hodge_star(), dx ^ dy ^ dz) self.assertEqual(dx.hodge_star(), dt ^ dy ^ dz) self.assertEqual(dy.hodge_star(), -dt ^ dx ^ dz) self.assertEqual(dz.hodge_star(), dt ^ dx ^ dy) self.assertEqual((dt ^ dx).hodge_star(), -dy ^ dz)
def test_dot(self): x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3")) xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx) xx_tmp, ddx = pc.setup_objects(xx) dx1, dx2, dx3 = ddx full_basis = list(xx) + list(xxd) dxdot2 = pc.DifferentialForm(1, full_basis, [0, 0, 0, 0, 1, 0]) w1 = x3 * dx2 with self.assertRaises(ValueError) as cm: w1.dot() w1.jet_extend_basis() dx2.jet_extend_basis() wdot1 = w1.dot() self.assertEqual(wdot1, xdot3 * dx2 + x3 * dxdot2)
def test_coeff_ido_do2(self): x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3")) xxd = pc.st.time_deriv(xx, xx) full_basis = pc.st.row_stack(xx, xxd) foo, ddx = pc.setup_objects(full_basis) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3 = ddx aa = sp.Matrix(sp.symbols("a1:10")) a1, a2, a3, a4, a5, a6, a7, a8, a9 = aa mu1 = a1 * dxdot1 + 3 * a2 * dx2 mu2 = a3 * dxdot2 - a4 * dx1 + 6 * a5 * dx2 mu3 = 7 * a6 * x1 * dxdot3 + a7 * dx3 sigma1 = (6, 7, 8) sigma1b = (6 + 3, 7 + 3, 8 + 3) sigma3 = (5, 6, 7) with self.assertRaises(ValueError) as cm: # the indices are too high pc.coeff_ido_derivorder(sigma1b, mu1, mu2, mu3) # important to call this before mu_i.jet_extend_basis() res2, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3, tds=aa) res3, dos = pc.coeff_ido_derivorder(sigma3, mu1, mu2, mu3, tds=aa) mu1.jet_extend_basis() mu2.jet_extend_basis() mu3.jet_extend_basis() Mu_0 = mu1 ^ mu2 ^ mu3 Mu_1 = mu1.dot(aa) ^ mu2.dot(aa) ^ mu3.dot(aa) res1, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res2) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma3), res3.subs(dos, 1))
def test_dot_2form(self): xx = sp.Matrix(sp.symbols("x1, x2, x3")) xxd = pc.st.time_deriv(xx, xx) xxdd = pc.st.time_deriv(xx, xx, order=2) XX = pc.st.row_stack(xx, xxd, xxdd) foo, ddx = pc.setup_objects(XX) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx a1, a2 = aa = sp.Matrix(sp.symbols("a1:3")) adot1, adot2 = aadot = st.time_deriv(aa, aa) b1, b2 = bb = sp.Matrix(sp.symbols("b1:3")) z = dx1 ^ dx2 res = z.dot() # Caution: using * instead of ^ because of pythons operator precedence (+ before ^) self.assertEqual(res, dxdot1 * dx2 + dx1 * dxdot2) z = 0 * dx1 ^ dx2 res = z.dot() self.assertEqual(res, z) z = a1 * dx1 ^ dx2 res = z.dot(additional_symbols=aa) self.assertEqual( res, adot1 * dx1 * dx2 + a1 * dxdot1 * dx2 + a1 * dx1 * dxdot2) z = a1 * dxdot1 ^ dx2 res = z.dot(additional_symbols=aa) self.assertEqual( res, adot1 * dxdot1 * dx2 + a1 * dxddot1 * dx2 + a1 * dxdot1 * dxdot2) z = a1 * dx1 * dx2 + a2 * dxdot1 * dx2 res = z.dot(additional_symbols=aa) exp_res = adot1*dx1*dx2 + (a1 + adot2)*dxdot1*dx2 + a1*dx1*dxdot2 + a2*dxdot1*dxdot2 +\ a2*dxddot1*dx2 self.assertEqual(res, exp_res)
def test_get_multiplied_baseform(self): x1, x2, x3 = xx = st.symb_vector("x1, x2, x3") xx, dxx = pc.setup_objects(xx) dx1, dx2, dx3 = dxx W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3) res1 = W.get_multiplied_baseform(dx1 ^ dx2) self.assertEqual(res1, 7 * dx1 ^ dx2) res2 = W.get_multiplied_baseform(dx2 ^ dx3) self.assertEqual(res2, 0 * dx1 ^ dx2) res3 = W.get_multiplied_baseform(dx1 ^ dx3) self.assertEqual(res3, 3 * x2 * dx1 ^ dx3) res4 = W.get_multiplied_baseform((0, 1)) self.assertEqual(res4, 7 * dx1 ^ dx2) res5 = W.get_multiplied_baseform((0, 2)) self.assertEqual(res5, 3 * x2 * dx1 ^ dx3) res6 = W.get_multiplied_baseform((1, 2)) self.assertEqual(res6, 0 * dx1 ^ dx3) with self.assertRaises(ValueError) as cm: res = W.get_multiplied_baseform(dx1) with self.assertRaises(ValueError) as cm: res = W.get_multiplied_baseform(x2 * dx1 ^ dx2) with self.assertRaises(ValueError) as cm: res = W.get_multiplied_baseform(dx2 ^ dx1) with self.assertRaises(ValueError) as cm: res = W.get_multiplied_baseform((1, 0))
def test_dot2(self): a1, a2, a3 = aa = sp.Matrix(sp.symbols("a1:4")) adot1, adot2, adot3 = aad = pc.st.time_deriv(aa, aa) xx = sp.Matrix(sp.symbols("x1, x2, x3")) xxd = pc.st.time_deriv(xx, xx) xxdd = pc.st.time_deriv(xx, xx, order=2) full_basis = pc.st.row_stack(xx, xxd, xxdd) xx_tmp, ddx = pc.setup_objects(full_basis) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx w1 = a1 * dx2 wdot1_1 = w1.dot() self.assertEqual(wdot1_1, a1 * dxdot2) wdot1_2 = w1.dot(aa) self.assertEqual(wdot1_2, adot1 * dx2 + a1 * dxdot2) w2 = a1 * dx2 + a2 * dxdot2 wdot2_expected = adot1 * dx2 + (a1 + adot2) * dxdot2 + a2 * dxddot2 self.assertEqual(wdot2_expected.coeff, w2.dot(aa).coeff)
def test_coeff_ido_do(self): x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3")) xxd = pc.st.time_deriv(xx, xx) xxdd = pc.st.time_deriv(xx, xx, order=2) full_basis = pc.st.row_stack(xx, xxd, xxdd) foo, ddx = pc.setup_objects(full_basis) dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx aa = sp.Matrix(sp.symbols("a1:10")) a1, a2, a3, a4, a5, a6, a7, a8, a9 = aa aad = pc.st.time_deriv(aa, aa) #adot1, adot2, adot3 =\ mu1 = a1 * dxdot1 + 3 * a2 * dx2 mu2 = a3 * dxdot2 - a4 * dx1 + 6 * a5 * dx2 mu3 = 7 * a6 * x1 * dxdot3 + a7 * dx3 Mu_0 = mu1 ^ mu2 ^ mu3 Mu_1 = mu1.dot(aa) ^ mu2.dot(aa) ^ mu3.dot(aa) # this once was a bug: self.assertEqual(xxdd[0].difforder, 2) sigma1 = (6, 7, 8) c_star = a1 * a3 * a6 * x1 * 7 # consistency check for local calculations self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), c_star) # in the following dos means difforder symbol res1, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3, tds=aa) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1) # test array type for sigma sigma_arr = pc.np.array([6.0, 7.0, 8.0]) res1b, dos = pc.coeff_ido_derivorder(sigma_arr, mu1, mu2, mu3, tds=aa) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1b) sigma2 = (5, 7, 8) res2, dos = pc.coeff_ido_derivorder(sigma2, mu1, mu2, mu3, tds=aa) self.assertEqual(res2, 0) sigma3 = (5, 6, 7) res3, dos = pc.coeff_ido_derivorder(sigma3, mu1, mu2, mu3, tds=aa) assert res3.has(dos) self.assertEqual(Mu_1.get_coeff_from_idcs(sigma3), res3.subs(dos, 1)) mu1.jet_extend_basis() mu2.jet_extend_basis() mu3.jet_extend_basis() Mu_2 = mu1.dot(aa).dot(aa) ^ mu2.dot(aa).dot(aa) ^ mu3.dot(aa).dot(aa) sigma4 = (5 + 3, 6 + 3, 7 + 3) res4 = Mu_2.get_coeff_from_idcs(sigma4) self.assertEqual(res4, res3.subs(dos, 2)) with self.assertRaises(ValueError) as cm: sigma5 = (1, 6, 7) pc.coeff_ido_derivorder(sigma5, mu1, mu2, mu3, tds=aa)
def setUp(self): self.xx, self.dx = pc.setup_objects("x1, x2, x3, x4, x5")