def test_differential_operators(): xyz_coords = (x, y, z) = symbols('x y z', real=True) (o3d, ex, ey, ez) = Ga.build('e', g=[1, 1, 1], coords=xyz_coords) f = o3d.mv('f', 'scalar', f=True) lap = o3d.grad*o3d.grad assert str(lap) == 'D{x}^2 + D{y}^2 + D{z}^2' assert str(lap * f) == 'D{x}^2f + D{y}^2f + D{z}^2f' sph_coords = (r, th, phi) = symbols('r theta phi', real=True) (sp3d, er, eth, ephi) = Ga.build('e', g=[1, r**2, r**2 * sin(th)**2], coords=sph_coords, norm=True) f = sp3d.mv('f', 'scalar', f=True) lap = sp3d.grad*sp3d.grad assert str(lap) == '2/r*D{r} + cos(theta)/(r**2*sin(theta))*D{theta} + D{r}^2 + r**(-2)*D{theta}^2 + 1/(r**2*sin(theta)**2)*D{phi}^2' assert str(lap * f) == 'D{r}^2f + 2*D{r}f/r + D{theta}^2f/r**2 + cos(theta)*D{theta}f/(r**2*sin(theta)) + D{phi}^2f/(r**2*sin(theta)**2)' A = o3d.mv('A','vector') xs = o3d.mv(x) assert o3d.grad*A == 0 assert str(A*o3d.grad) == 'A__x*D{x} + A__y*D{y} + A__z*D{z} + e_x^e_y*(-A__y*D{x} + A__x*D{y}) + e_x^e_z*(-A__z*D{x} + A__x*D{z}) + e_y^e_z*(-A__z*D{y} + A__y*D{z})' assert o3d.grad*xs == ex assert str(xs*o3d.grad) == 'e_x*x*D{x} + e_y*x*D{y} + e_z*x*D{z}' assert str(o3d.grad*(o3d.grad+xs)) == 'D{x}^2 + D{y}^2 + D{z}^2 + e_x*D{}' assert str((o3d.grad+xs)*o3d.grad) == 'D{x}^2 + D{y}^2 + D{z}^2 + e_x*x*D{x} + e_y*x*D{y} + e_z*x*D{z}' return
def test_basic_multivector_operations(): g3d, ex, ey, ez = Ga.build('e*x|y|z') A = g3d.mv('A', 'mv') assert str(A) == 'A + A__x*e_x + A__y*e_y + A__z*e_z + A__xy*e_x^e_y + A__xz*e_x^e_z + A__yz*e_y^e_z + A__xyz*e_x^e_y^e_z' X = g3d.mv('X', 'vector') Y = g3d.mv('Y', 'vector') assert str(X) == 'X__x*e_x + X__y*e_y + X__z*e_z' assert str(Y) == 'Y__x*e_x + Y__y*e_y + Y__z*e_z' assert str((X*Y)) == '(e_x.e_x)*X__x*Y__x + (e_x.e_y)*X__x*Y__y + (e_x.e_y)*X__y*Y__x + (e_x.e_z)*X__x*Y__z + (e_x.e_z)*X__z*Y__x + (e_y.e_y)*X__y*Y__y + (e_y.e_z)*X__y*Y__z + (e_y.e_z)*X__z*Y__y + (e_z.e_z)*X__z*Y__z + (X__x*Y__y - X__y*Y__x)*e_x^e_y + (X__x*Y__z - X__z*Y__x)*e_x^e_z + (X__y*Y__z - X__z*Y__y)*e_y^e_z' assert str((X ^ Y)) == '(X__x*Y__y - X__y*Y__x)*e_x^e_y + (X__x*Y__z - X__z*Y__x)*e_x^e_z + (X__y*Y__z - X__z*Y__y)*e_y^e_z' assert str((X | Y)) == '(e_x.e_x)*X__x*Y__x + (e_x.e_y)*X__x*Y__y + (e_x.e_y)*X__y*Y__x + (e_x.e_z)*X__x*Y__z + (e_x.e_z)*X__z*Y__x + (e_y.e_y)*X__y*Y__y + (e_y.e_z)*X__y*Y__z + (e_y.e_z)*X__z*Y__y + (e_z.e_z)*X__z*Y__z' g2d, ex, ey = Ga.build('e*x|y') X = g2d.mv('X', 'vector') A = g2d.mv('A', 'spinor') assert str(X) == 'X__x*e_x + X__y*e_y' assert str(A) == 'A + A__xy*e_x^e_y' assert str((X | A)) == '-A__xy*((e_x.e_y)*X__x + (e_y.e_y)*X__y)*e_x + A__xy*((e_x.e_x)*X__x + (e_x.e_y)*X__y)*e_y' assert str((X < A)) == '(-(e_x.e_y)*A__xy*X__x - (e_y.e_y)*A__xy*X__y + A*X__x)*e_x + ((e_x.e_x)*A__xy*X__x + (e_x.e_y)*A__xy*X__y + A*X__y)*e_y' assert str((A > X)) == '((e_x.e_y)*A__xy*X__x + (e_y.e_y)*A__xy*X__y + A*X__x)*e_x + (-(e_x.e_x)*A__xy*X__x - (e_x.e_y)*A__xy*X__y + A*X__y)*e_y' o2d, ex, ey = Ga.build('e*x|y', g=[1, 1]) X = o2d.mv('X', 'vector') A = o2d.mv('A', 'spinor') assert str(X) == 'X__x*e_x + X__y*e_y' assert str(A) == 'A + A__xy*e_x^e_y' assert str((X*A)) == '(A*X__x - A__xy*X__y)*e_x + (A*X__y + A__xy*X__x)*e_y' assert str((X | A)) == '-A__xy*X__y*e_x + A__xy*X__x*e_y' assert str((X < A)) == '(A*X__x - A__xy*X__y)*e_x + (A*X__y + A__xy*X__x)*e_y' assert str((X > A)) == 'A*X__x*e_x + A*X__y*e_y' assert str((A*X)) == '(A*X__x + A__xy*X__y)*e_x + (A*X__y - A__xy*X__x)*e_y' assert str((A | X)) == 'A__xy*X__y*e_x - A__xy*X__x*e_y' assert str((A < X)) == 'A*X__x*e_x + A*X__y*e_y' assert str((A > X)) == '(A*X__x + A__xy*X__y)*e_x + (A*X__y - A__xy*X__x)*e_y' return
def test_extract_plane_and_line(): """ Show that conformal trivector encodes planes and lines. See D&L section 10.4.2 """ metric = '# # # 0 0,' + \ '# # # 0 0,' + \ '# # # 0 0,' + \ '0 0 0 0 2,' + \ '0 0 0 2 0' cf3d, p1, p2, p3, n, nbar = Ga.build('p1 p2 p3 n nbar', g=metric) P1 = F(p1, n, nbar) P2 = F(p2, n, nbar) P3 = F(p3, n, nbar) #Line through p1 and p2 L = P1 ^ P2 ^ n delta = (L | n) | nbar delta_test = 2*p1 - 2*p2 diff = delta - delta_test assert diff == S.Zero #Plane through p1, p2, and p3 C = P1 ^ P2 ^ P3 delta = ((C ^ n) | n) | nbar delta_test = 2*(p1 ^ p2) - 2*(p1 ^ p3) + 2*(p2 ^ p3) diff = delta - delta_test assert diff == S.Zero
def main(): Eprint() X = (x,y,z) = symbols('x y z',real=True) (o3d,ex,ey,ez) = Ga.build('e_x e_y e_z',g=[1,1,1],coords=(x,y,z)) A = x*(ey^ez) + y*(ez^ex) + z*(ex^ey) print 'A =', A print 'grad^A =',(o3d.grad^A).simplify() print f = o3d.mv(1/sqrt(x**2 + y**2 + z**2)) print 'f =', f print 'grad*f =',(o3d.grad*f).simplify() print B = f*A print 'B =', B print Curl_B = o3d.grad^B print 'grad^B =', Curl_B.simplify() return
def basic_multivector_operations_3D(): Print_Function() (g3d,ex,ey,ez) = Ga.build('e*x|y|z') print 'g_{ij} =',g3d.g A = g3d.mv('A','mv') A.Fmt(1,'A') A.Fmt(2,'A') A.Fmt(3,'A') A.even().Fmt(1,'%A_{+}') A.odd().Fmt(1,'%A_{-}') X = g3d.mv('X','vector') Y = g3d.mv('Y','vector') X.Fmt(1,'X') Y.Fmt(1,'Y') (X*Y).Fmt(2,'X*Y') (X^Y).Fmt(2,'X^Y') (X|Y).Fmt(2,'X|Y') return
def test_vector_extraction(): """ Show that conformal bivector encodes two points. See D&L Section 10.4.1 """ metric = '0 -1 #,' + \ '-1 0 #,' + \ '# # #' cext, P1, P2, a = Ga.build('P1 P2 a', g=metric) """ P1 and P2 are null vectors and hence encode points in conformal space. Show that P1 and P2 can be extracted from the bivector B = P1^P2. a is a third vector in the conformal space with a.B not 0. """ B = P1 ^ P2 Bsq = B*B ap = a - (a ^ B)*B Ap = ap + ap*B Am = ap - ap*B P1dota = cext.g[0,2] P2dota = cext.g[1,2] Ap_test = (-2*P2dota)*P1 Am_test = (-2*P1dota)*P2 assert Ap == Ap_test assert Am == Am_test Ap2 = Ap*Ap Am2 = Am*Am assert Ap2 == S.Zero assert Am2 == S.Zero
def Maxwells_Equations_in_Geom_Calculus(): Print_Function() X = symbols('t x y z',real=True) (st4d,g0,g1,g2,g3) = Ga.build('gamma*t|x|y|z',g=[1,-1,-1,-1],coords=X) I = st4d.i B = st4d.mv('B','vector',f=True) E = st4d.mv('E','vector',f=True) B.set_coef(1,0,0) E.set_coef(1,0,0) B *= g0 E *= g0 J = st4d.mv('J','vector',f=True) F = E+I*B print r'\text{Pseudo Scalar\;\;}I =',I print '\\text{Magnetic Field Bi-Vector\\;\\;} B = \\bm{B\\gamma_{t}} =',B print '\\text{Electric Field Bi-Vector\\;\\;} E = \\bm{E\\gamma_{t}} =',E print '\\text{Electromagnetic Field Bi-Vector\\;\\;} F = E+IB =',F print '%\\text{Four Current Density\\;\\;} J =',J gradF = st4d.grad*F print '#Geom Derivative of Electomagnetic Field Bi-Vector' gradF.Fmt(3,'grad*F') print '#Maxwell Equations' print 'grad*F = J' print '#Div $E$ and Curl $H$ Equations' (gradF.get_grade(1)-J).Fmt(3,'%\\grade{\\nabla F}_{1} -J = 0') print '#Curl $E$ and Div $B$ equations' (gradF.get_grade(3)).Fmt(3,'%\\grade{\\nabla F}_{3} = 0') return
def test_extracting_vectors_from_conformal_2_blade(): metric = '0 -1 #,' + \ '-1 0 #,' + \ '# # #' (cf1d, P1, P2, a) = Ga.build('P1 P2 a', g=metric) B = P1 ^ P2 Bsq = B*B assert str(Bsq) == '1' ap = a - (a ^ B)*B assert str(ap) == '-(P2.a)*P1 - (P1.a)*P2' Ap = ap + ap*B Am = ap - ap*B assert str(Ap) == '-2*(P2.a)*P1' assert str(Am) == '-2*(P1.a)*P2' assert str(Ap*Ap) == '0' assert str(Am*Am) == '0' aB = a | B assert str(aB) == '-(P2.a)*P1 + (P1.a)*P2' return
def Lorentz_Tranformation_in_Geog_Algebra(): Print_Function() (alpha,beta,gamma) = symbols('alpha beta gamma') (x,t,xp,tp) = symbols("x t x' t'",real=True) (st2d,g0,g1) = Ga.build('gamma*t|x',g=[1,-1]) from sympy import sinh,cosh R = cosh(alpha/2)+sinh(alpha/2)*(g0^g1) X = t*g0+x*g1 Xp = tp*g0+xp*g1 print 'R =',R print r"#%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} = t'\bm{\gamma'_{t}}+x'\bm{\gamma'_{x}} = R\lp t'\bm{\gamma_{t}}+x'\bm{\gamma_{x}}\rp R^{\dagger}" Xpp = R*Xp*R.rev() Xpp = Xpp.collect() Xpp = Xpp.trigsimp() print r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =",Xpp Xpp = Xpp.subs({sinh(alpha):gamma*beta,cosh(alpha):gamma}) print r'%\f{\sinh}{\alpha} = \gamma\beta' print r'%\f{\cosh}{\alpha} = \gamma' print r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =",Xpp.collect() return
def test_conformal_representations_of_circles_lines_spheres_and_planes(): global n, nbar metric = '1 0 0 0 0,0 1 0 0 0,0 0 1 0 0,0 0 0 0 2,0 0 0 2 0' (cf3d, ex, ey, ez, n, nbar) = Ga.build('e_x e_y e_z n nbar', g=metric) x, y, z = symbols('x y z', real=True) e = n + nbar #conformal representation of points A = make_vector(ex, cf3d) B = make_vector(ey, cf3d) C = make_vector(-ex, cf3d) D = make_vector(ez, cf3d) X = make_vector(x*ex + y*ey +z*ez, cf3d) assert A == ex + (n - nbar)/S(2) assert B == ey + (n - nbar)/S(2) assert C == -ex + (n - nbar)/S(2) assert D == ez + (n - nbar)/S(2) assert X == x*ex + y*ey + z*ez + (x**2/2 + y**2/2 + z**2/2)*n - nbar/2 assert A ^ B ^ C ^ X == -z*(ex^ey^ez^n) + z*(ex^ey^ez^nbar) + ((x**2 + y**2 + z**2 - S(1))/2)*(ex^ey^n^nbar) assert A ^ B ^ n ^ X == -z*(ex^ey^ez^n) + ((x + y - S(1))/2)*(ex^ey^n^nbar) + (z/2)*(ex^ez^n^nbar) - (z/2)*(ey^ez^n^nbar) assert A ^ B ^ C ^ D ^ X == ((-x**2 - y**2 - z**2 + S(1))/2)*ex^ey^ez^n^nbar assert A ^ B ^ n ^ D ^ X == ((-x - y - z + S(1))/2)*(ex^ey^ez^n^nbar) L = (A ^ B ^ e) ^ X assert L == -z*(ex^ey^ez^n) - z*(ex^ey^ez^nbar) + (-x**2/2 + x - y**2/2 + y - z**2/2 - S(1)/2)*(ex^ey^n^nbar) + z*(ex^ez^n^nbar) - z*(ey^ez^n^nbar) return
def derivatives_in_spherical_coordinates(): Print_Function() coords = (r,th,phi) = symbols('r theta phi', real=True) (sp3d,er,eth,ephi) = Ga.build('e_r e_theta e_phi',g=[1,r**2,r**2*sin(th)**2],coords=coords,norm=True) grad = sp3d.grad f = sp3d.mv('f','scalar',f=True) A = sp3d.mv('A','vector',f=True) B = sp3d.mv('B','bivector',f=True) print 'f =',f print 'A =',A print 'B =',B print 'grad*f =',grad*f print 'grad|A =',grad|A print 'grad\\times A = -I*(grad^A) =',-sp3d.i*(grad^A) print '%\\nabla^{2}f =',grad|(grad*f) print 'grad^B =',grad^B """ print '( \\nabla\\W\\nabla )\\bm{e}_{r} =',((grad^grad)*er).trigsimp() print '( \\nabla\\W\\nabla )\\bm{e}_{\\theta} =',((grad^grad)*eth).trigsimp() print '( \\nabla\\W\\nabla )\\bm{e}_{\\phi} =',((grad^grad)*ephi).trigsimp() """ return
def test_derivatives_in_rectangular_coordinates(): X = (x, y, z) = symbols('x y z') o3d, ex, ey, ez = Ga.build('e_x e_y e_z', g=[1,1,1], coords=X) grad = o3d.grad f = o3d.mv('f', 'scalar', f=True) A = o3d.mv('A', 'vector', f=True) B = o3d.mv('B', 'bivector', f=True) C = o3d.mv('C', 'mv', f=True) assert str(f) == 'f' assert str(A) == 'A__x*e_x + A__y*e_y + A__z*e_z' assert str(B) == 'B__xy*e_x^e_y + B__xz*e_x^e_z + B__yz*e_y^e_z' assert str(C) == 'C + C__x*e_x + C__y*e_y + C__z*e_z + C__xy*e_x^e_y + C__xz*e_x^e_z + C__yz*e_y^e_z + C__xyz*e_x^e_y^e_z' assert str(grad*f) == 'D{x}f*e_x + D{y}f*e_y + D{z}f*e_z' assert str(grad | A) == 'D{x}A__x + D{y}A__y + D{z}A__z' assert str(grad*A) == 'D{x}A__x + D{y}A__y + D{z}A__z + (-D{y}A__x + D{x}A__y)*e_x^e_y + (-D{z}A__x + D{x}A__z)*e_x^e_z + (-D{z}A__y + D{y}A__z)*e_y^e_z' assert str(-o3d.I()*(grad ^ A)) == '(-D{z}A__y + D{y}A__z)*e_x + (D{z}A__x - D{x}A__z)*e_y + (-D{y}A__x + D{x}A__y)*e_z' assert str(grad*B) == '(-D{y}B__xy - D{z}B__xz)*e_x + (D{x}B__xy - D{z}B__yz)*e_y + (D{x}B__xz + D{y}B__yz)*e_z + (D{z}B__xy - D{y}B__xz + D{x}B__yz)*e_x^e_y^e_z' assert str(grad ^ B) == '(D{z}B__xy - D{y}B__xz + D{x}B__yz)*e_x^e_y^e_z' assert str(grad | B) == '(-D{y}B__xy - D{z}B__xz)*e_x + (D{x}B__xy - D{z}B__yz)*e_y + (D{x}B__xz + D{y}B__yz)*e_z' assert str(grad < A) == 'D{x}A__x + D{y}A__y + D{z}A__z' assert str(grad > A) == 'D{x}A__x + D{y}A__y + D{z}A__z' assert str(grad < B) == '(-D{y}B__xy - D{z}B__xz)*e_x + (D{x}B__xy - D{z}B__yz)*e_y + (D{x}B__xz + D{y}B__yz)*e_z' assert str(grad > B) == '0' assert str(grad < C) == 'D{x}C__x + D{y}C__y + D{z}C__z + (D{x}C - D{y}C__xy - D{z}C__xz)*e_x + (D{y}C + D{x}C__xy - D{z}C__yz)*e_y + (D{z}C + D{x}C__xz + D{y}C__yz)*e_z + D{z}C__xyz*e_x^e_y - D{y}C__xyz*e_x^e_z + D{x}C__xyz*e_y^e_z' assert str(grad > C) == 'D{x}C__x + D{y}C__y + D{z}C__z + D{x}C*e_x + D{y}C*e_y + D{z}C*e_z' return
def main(): Print_Function() (a, b, c) = abc = symbols('a,b,c',real=True) (o3d, ea, eb, ec) = Ga.build('e_a e_b e_c', g=[1, 1, 1], coords=abc) grad = o3d.grad x = symbols('x',real=True) A = o3d.lt([[x*a*c**2,x**2*a*b*c,x**2*a**3*b**5],\ [x**3*a**2*b*c,x**4*a*b**2*c**5,5*x**4*a*b**2*c],\ [x**4*a*b**2*c**4,4*x**4*a*b**2*c**2,4*x**4*a**5*b**2*c]]) print 'A =',A v = a*ea+b*eb+c*ec print 'v =',v f = v|A(v) print r'%f = v\cdot \f{A}{v} =',f (grad * f).Fmt(3,r'%\nabla f') Av = A(v) print r'%\f{A}{v} =', Av (grad * Av).Fmt(3,r'%\nabla \f{A}{v}') return
def test_substitution(): o3d, e_x, e_y, e_z = Ga.build('e_x e_y e_z', g='1 0 0, 0 1 0, 0 0 1') x, y, z = symbols('x y z') X = x*e_x + y*e_y + z*e_z Y = X.subs([(x, 2), (y, 3), (z, 4)]) assert Y == 2*e_x + 3*e_y + 4*e_z
def test_rmul(): """ Test for commutative scalar multiplication. Leftover from when sympy and numpy were not working together and __mul__ and __rmul__ would not give the same answer. """ g3d, x, y, z = Ga.build('x y z') a, b, c = symbols('a b c') assert 5*x == x*5 assert Rational(1, 2)*x == x*Rational(1, 2) assert a*x == x*a
def test_derivative(): coords = x, y, z = symbols('x y z') o3d, e_x, e_y, e_z = Ga.build('e', g=[1, 1, 1], coords=coords) grad = o3d.grad X = x*e_x + y*e_y + z*e_z a = o3d.mv('a', 'vector') assert (grad * (X | a)) == a assert (grad * (X*X)) == 2*X assert grad * (X*X*X) == 5*X*X assert (grad *X).scalar() == 3
def test_constructor(): """ Test various multivector constructors """ o3d, e_1, e_2, e_3 = Ga.build('e_1 e_2 e_3', g=[1,1,1]) assert str(o3d.mv('a', 'scalar')) == 'a' assert str(o3d.mv('a', 'vector')) == 'a__1*e_1 + a__2*e_2 + a__3*e_3' assert str(o3d.mv('a', 'pseudo')) == 'a__123*e_1^e_2^e_3' assert str(o3d.mv('a', 'spinor')) == 'a + a__12*e_1^e_2 + a__13*e_1^e_3 + a__23*e_2^e_3' assert str(o3d.mv('a', 'mv')) == 'a + a__1*e_1 + a__2*e_2 + a__3*e_3 + a__12*e_1^e_2 + a__13*e_1^e_3 + a__23*e_2^e_3 + a__123*e_1^e_2^e_3' assert str(o3d.mv('a', 'bivector')) == 'a__12*e_1^e_2 + a__13*e_1^e_3 + a__23*e_2^e_3'
def Mv_setup_options(): Print_Function() (o3d,e1,e2,e3) = Ga.build('e_1 e_2 e_3',g=[1,1,1]) v = o3d.mv('v', 'vector') print v (o3d,e1,e2,e3) = Ga.build('e*1|2|3',g=[1,1,1]) v = o3d.mv('v', 'vector') print v (o3d,e1,e2,e3) = Ga.build('e*x|y|z',g=[1,1,1]) v = o3d.mv('v', 'vector') print v coords = symbols('x y z',real=True) (o3d,e1,e2,e3) = Ga.build('e',g=[1,1,1],coords=coords) v = o3d.mv('v', 'vector') print v return
def make_cf3d(): if Cf3d.ga_flg: return Cf3d.ga_flg = True Cf3d.basis_sups = ['__x','__y','__z'] Cf3d.basis = 'e_x e_y e_z e ebar' (Cf3d.cf3d,Cf3d.ex,Cf3d.ey,Cf3d.ez,Cf3d.e,Cf3d.ebar) = Ga.build(Cf3d.basis,g=[1,1,1,1,-1]) Cf3d.xyz = (Cf3d.ex,Cf3d.ey,Cf3d.ez) Cf3d.n = Cf3d.e + Cf3d.ebar Cf3d.nbar = Cf3d.e - Cf3d.ebar return
def test_contraction(): """ Test for inner product and left and right contraction """ o3d, e_1, e_2, e_3 = Ga.build('e_1 e_2 e_3', g='1 0 0, 0 1 0, 0 0 1') assert ((e_1 ^ e_3) | e_1) == -e_3 assert ((e_1 ^ e_3) > e_1) == -e_3 assert (e_1 | (e_1 ^ e_3)) == e_3 assert (e_1 < (e_1 ^ e_3)) == e_3 assert ((e_1 ^ e_3) < e_1) == 0 assert (e_1 > (e_1 ^ e_3)) == 0
def test_rounding_numerical_components(): (o3d, ex, ey, ez) = Ga.build('e_x e_y e_z', g=[1,1,1]) X = 1.2*ex + 2.34*ey + 0.555*ez Y = 0.333*ex + 4*ey + 5.3*ez assert str(X) == '1.2*e_x + 2.34*e_y + 0.555*e_z' assert str(Nga(X, 2)) == '1.2*e_x + 2.3*e_y + 0.55*e_z' assert str(X*Y) == '12.7011000000000 + 4.02078*e_x^e_y + 6.175185*e_x^e_z + 10.182*e_y^e_z' assert str(Nga(X*Y, 2)) == '13. + 4.0*e_x^e_y + 6.2*e_x^e_z + 10.0*e_y^e_z' return
def test_metrics(): """ Test specific metrics (diagpq, arbitrary_metric, arbitrary_metric_conformal) """ o3d, p1, p2, p3 = Ga.build('p1 p2 p3', g=[1,1,1], debug=0) x1, y1, z1 = symbols('x1 y1 z1') x2, y2, z2 = symbols('x2 y2 z2') v1 = x1*p1 + y1*p2 + z1*p3 v2 = x2*p1 + y2*p2 + z2*p3 prod1 = v1*v2 prod2 = (v1|v2) + (v1^v2) diff = prod1 - prod2 assert diff == o3d.mv(S.Zero) g3d, p1, p2, p3 = Ga.build('p1 p2 p3', g='# # #, # # #, # # #', debug=0) v1 = x1*p1 + y1*p2 + z1*p3 v2 = x2*p1 + y2*p2 + z2*p3 prod1 = v1*v2 prod2 = (v1|v2) + (v1^v2) diff = prod1 - prod2 assert diff == g3d.mv(S.Zero)
def test_geometry(): """ Test conformal geometric description of circles, lines, spheres, and planes. """ metric = '1 0 0 0 0,' + \ '0 1 0 0 0,' + \ '0 0 1 0 0,' + \ '0 0 0 0 2,' + \ '0 0 0 2 0' cf3d, e0, e1, e2, n, nbar = Ga.build('e0 e1 e2 n nbar', g=metric) e = n + nbar #conformal representation of points A = F(e0, n, nbar) # point a = (1,0,0) A = F(a) B = F(e1, n, nbar) # point b = (0,1,0) B = F(b) C = F(-1*e0, n, nbar) # point c = (-1,0,0) C = F(c) D = F(e2, n, nbar) # point d = (0,0,1) D = F(d) x0, x1, x2 = symbols('x0 x1 x2') x = x0 * e0 + x1 * e1 + x2 * e2 X = F(x, n, nbar) Circle = A ^ B ^ C ^ X Line = A ^ B ^ n ^ X Sphere = A ^ B ^ C ^ D ^ X Plane = A ^ B ^ n ^ D ^ X #Circle through a, b, and c Circle_test = -x2*(e0 ^ e1 ^ e2 ^ n) + x2*( e0 ^ e1 ^ e2 ^ nbar) + Rational(1, 2)*(-1 + x0**2 + x1**2 + x2**2)*(e0 ^ e1 ^ n ^ nbar) diff = Circle - Circle_test assert diff == S.Zero #Line through a and b Line_test = -x2*(e0 ^ e1 ^ e2 ^ n) + \ Rational(1, 2)*(-1 + x0 + x1)*(e0 ^ e1 ^ n ^ nbar) + \ (Rational(1, 2)*x2)*(e0 ^ e2 ^ n ^ nbar) + \ (-Rational(1, 2)*x2)*(e1 ^ e2 ^ n ^ nbar) diff = Line - Line_test assert diff == S.Zero #Sphere through a, b, c, and d Sphere_test = Rational(1, 2)*(1 - x0**2 - x1**2 - x2**2)*(e0 ^ e1 ^ e2 ^ n ^ nbar) diff = Sphere - Sphere_test assert diff == S.Zero #Plane through a, b, and d Plane_test = Rational(1, 2)*(1 - x0 - x1 - x2)*(e0 ^ e1 ^ e2 ^ n ^ nbar) diff = Plane - Plane_test assert diff == S.Zero
def test_check_generalized_BAC_CAB_formulas(): g5d, a, b, c, d, e = Ga.build('a b c d e') assert str(a | (b*c)) == '-(a.c)*b + (a.b)*c' assert str(a | (b ^ c)) == '-(a.c)*b + (a.b)*c' assert str(a | (b ^ c ^ d)) == '(a.d)*b^c - (a.c)*b^d + (a.b)*c^d' assert str((a | (b ^ c)) + (c | (a ^ b)) + (b | (c ^ a))) == '0' assert str(a*(b ^ c) - b*(a ^ c) + c*(a ^ b)) == '3*a^b^c' assert str(a*(b ^ c ^ d) - b*(a ^ c ^ d) + c*(a ^ b ^ d) - d*(a ^ b ^ c)) == '4*a^b^c^d' assert str((a ^ b) | (c ^ d)) == '-(a.c)*(b.d) + (a.d)*(b.c)' assert str(((a ^ b) | c) | d) == '-(a.c)*(b.d) + (a.d)*(b.c)' assert str(Com(a ^ b, c ^ d)) == '-(b.d)*a^c + (b.c)*a^d + (a.d)*b^c - (a.c)*b^d' assert str((a | (b ^ c)) | (d ^ e)) == '(-(a.b)*(c.e) + (a.c)*(b.e))*d + ((a.b)*(c.d) - (a.c)*(b.d))*e' return
def basic_multivector_operations_2D(): Print_Function() (g2d,ex,ey) = Ga.build('e*x|y') print 'g_{ij} =',g2d.g X = g2d.mv('X','vector') A = g2d.mv('A','spinor') X.Fmt(1,'X') A.Fmt(1,'A') (X|A).Fmt(2,'X|A') (X<A).Fmt(2,'X<A') (A>X).Fmt(2,'A>X') return
def main(): Eprint() (o3d,ex,ey,ez) = Ga.build('e*x|y|z',g=[1,1,1]) u = o3d.mv('u','vector') v = o3d.mv('v','vector') w = o3d.mv('w','vector') print u print v uv = u^v print uv print uv.is_blade() exp_uv = uv.exp() print 'exp(uv) =', exp_uv return
def test_derivatives_in_spherical_coordinates(): X = (r, th, phi) = symbols('r theta phi') sph3d, er, eth, ephi = Ga.build('e_r e_theta e_phi', g=[1,r**2,r**2*sin(th)**2], coords=X, norm=True) grad = sph3d.grad f = sph3d.mv('f', 'scalar', f=True) A = sph3d.mv('A', 'vector', f=True) B = sph3d.mv('B', 'bivector', f=True) assert str(f) == 'f' assert str(A) == 'A__r*e_r + A__theta*e_theta + A__phi*e_phi' assert str(B) == 'B__rtheta*e_r^e_theta + B__rphi*e_r^e_phi + B__thetaphi*e_theta^e_phi' assert str(grad*f) == 'D{r}f*e_r + D{theta}f*e_theta/r + D{phi}f*e_phi/(r*sin(theta))' assert str(grad | A) == 'D{r}A__r + (A__r + D{theta}A__theta)/r + (A__r*sin(theta) + A__theta*cos(theta) + D{phi}A__phi)/(r*sin(theta))' assert str(-sph3d.I()*(grad ^ A)) == '(A__phi/tan(theta) + D{theta}A__phi - D{phi}A__theta/sin(theta))*e_r/r + (-r*D{r}A__phi - A__phi + D{phi}A__r/sin(theta))*e_theta/r + (r*D{r}A__theta + A__theta - D{theta}A__r)*e_phi/r' assert str(grad ^ B) == '(r*D{r}B__thetaphi - B__rphi/tan(theta) + 2*B__thetaphi - D{theta}B__rphi + D{phi}B__rtheta/sin(theta))*e_r^e_theta^e_phi/r' return
def derivatives_in_elliptic_cylindrical_coordinates(): Print_Function() a = symbols('a', real=True) coords = (u,v,z) = symbols('u v z', real=True) (elip3d,er,eth,ephi) = Ga.build('e_u e_v e_z',X=[a*cosh(u)*cos(v),a*sinh(u)*sin(v),z],coords=coords,norm=True) grad = elip3d.grad f = elip3d.mv('f','scalar',f=True) A = elip3d.mv('A','vector',f=True) B = elip3d.mv('B','bivector',f=True) print 'f =',f print 'A =',A print 'B =',B print 'grad*f =',grad*f print 'grad|A =',grad|A print '-I*(grad^A) =',-elip3d.i*(grad^A) print 'grad^B =',grad^B return
def derivatives_in_prolate_spheroidal_coordinates(): Print_Function() a = symbols('a', real=True) coords = (xi,eta,phi) = symbols('xi eta phi', real=True) (ps3d,er,eth,ephi) = Ga.build('e_xi e_eta e_phi',X=[a*sinh(xi)*sin(eta)*cos(phi),a*sinh(xi)*sin(eta)*sin(phi), a*cosh(xi)*cos(eta)],coords=coords,norm=True) grad = ps3d.grad f = ps3d.mv('f','scalar',f=True) A = ps3d.mv('A','vector',f=True) B = ps3d.mv('B','bivector',f=True) print 'f =',f print 'A =',A print 'B =',B print 'grad*f =',grad*f print 'grad|A =',grad|A (-ps3d.i*(grad^A)).Fmt(3,'-I*(grad^A)') (grad^B).Fmt(3,'grad^B') return
def Dirac_Equation_in_Geog_Calculus(): Print_Function() coords = symbols('t x y z',real=True) (st4d,g0,g1,g2,g3) = Ga.build('gamma*t|x|y|z',g=[1,-1,-1,-1],coords=coords) I = st4d.i (m,e) = symbols('m e') psi = st4d.mv('psi','spinor',f=True) A = st4d.mv('A','vector',f=True) sig_z = g3*g0 print '\\text{4-Vector Potential\\;\\;}\\bm{A} =',A print '\\text{8-component real spinor\\;\\;}\\bm{\\psi} =',psi dirac_eq = (st4d.grad*psi)*I*sig_z-e*A*psi-m*psi*g0 dirac_eq = dirac_eq.simplify() dirac_eq.Fmt(3,r'%\text{Dirac Equation\;\;}\nabla \bm{\psi} I \sigma_{z}-e\bm{A}\bm{\psi}-m\bm{\psi}\gamma_{t} = 0') return