def testcreation2(self): a=g.symbol("a") b=g.symbol("b") x=g.symbol("x") y=g.symbol("y") m=g.matrix([[a,0],[0,b]]) self.assertEqual(repr(m),"[[a,0],[0,b]]") self.assertNotEqual(repr(m),"[[a,1],[0,b]]") m=g.matrix([[0,0],[0,0]]) self.assertEqual(repr(m),"[[0,0],[0,0]]") m[0,0]=a self.assertEqual(repr(m),"[[a,0],[0,0]]") m[1,1]=b self.assertEqual(repr(m),"[[a,0],[0,b]]") self.assertNotEqual(repr(m),"[[a,0],[b,0]]") self.assertEqual(m[0,0],a) self.assertNotEqual(m[0,0],b) self.assertEqual(m[0,1],0) self.assertNotEqual(m[0,1],b) self.assertEqual(m[1,1],b) self.assertNotEqual(m[1,1],0) M=g.matrix m[0,1]=a self.assertEqual(m,M([[a,a],[0,b]])) m[0,1]=b self.assertEqual(m,M([[a,b],[0,b]])) m[0,1]=b*a self.assertEqual(m,M([[a,a*b],[0,b]]))
def testsubs(self): mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4,True) A=g.symbol("A") e=g.indexed(A,mu) self.assertEqual(str(e),"A~mu") self.assertEqual(str(e.subs(mu==nu)),"A.nu") self.assertEqual(str(e.subs(mu==0)),"A~0")
def testsimplify(self): mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4) A=g.symbol("A") e1=g.indexed(A,mu,mu.toggle_variance()) e2=g.indexed(A,nu,nu.toggle_variance()) self.assertNotEqual(e1,e2) self.assertEqual((e1-e2).simplify_indexed(),0)
def testvaridx3(self): mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4) A=g.symbol("A") self.assertEqual(str(g.indexed(A,mu,nu)),"A~mu~nu") self.assertEqual(str(g.indexed(A,mu,nu.toggle_variance())),"A~mu.nu") self.assertEqual(str(g.indexed(A,mu.toggle_variance(),nu)),"A.mu~nu") self.failUnless(mu.is_contravariant()) self.failUnless(nu.is_contravariant())
def test_multivariate_polynomial_analyze(self): x = symbol("x") y = symbol("y") p_correct = [ y**2+11*y, 5*y**2-2*y, -1, 4*y ] PolyInp = 4*pow(x,3)*y + 5*x*pow(y,2) + 3*y - pow(x+y,2) + 2*pow(y+2,2) - 8 Poly = PolyInp.expand() for i in xrange(Poly.ldegree(x),Poly.degree(x)+1): self.assertEqual(Poly.coeff(x,i), p_correct[i]) self.assertEqual(Poly.collect(y), -x**2+(5*x+1)*y**2+(-2*x+4*x**3+11)*y)
def testrelat3(self): x=g.symbol("x") y=g.symbol("y") r1=x/y r2=2*(x/y) r2/=2 self.assertEqual(r1,r2) self.assertNotEqual(r1,r2+1) r3=r1-r2 self.assertEqual(r3,0) self.assertNotEqual(r3,1)
def dotest(self,s): def t(a,b): s(a,b) s(b,a) a=g.numeric(2) b=g.numeric("1.3") c=g.symbol("x") d=g.symbol("y") e=pow(c,d)*d f=5 h=5.5 t(a,a) t(a,b) t(a,c) t(a,d) t(a,e) t(a,f) t(a,h) t(b,b) t(b,c) t(b,d) t(b,e) t(b,f) t(b,h) t(c,c) t(c,d) t(c,e) t(c,f) t(c,h) t(d,d) t(d,e) t(d,f) t(d,h) t(e,e) t(e,f) t(e,h) t(f,f) t(f,h) t(h,h)
def __init__(self, name = 'x'): if isinstance(name, str): self.data = _g.symbol(name) elif isinstance(name, _g.symbol): self.data = name else: raise ValueError, "Can not construct a Symbol from a %s" % type(name) self.spatial_symbs = [self.data] self.time = None
def testlorentz(self): mu=g.varidx(g.symbol("mu"),4) e=g.delta_tensor(g.varidx(0,4),mu.toggle_variance())*\ g.lorentz_g(mu,g.varidx(0,4)) self.assertEqual(e.simplify_indexed(),1) e=g.delta_tensor(g.varidx(0,4),mu.toggle_variance())*\ g.lorentz_g(mu,g.varidx(0,4),True) self.assertEqual(e.simplify_indexed(),-1)
def test_basic_print(self): a = g.symbol('a','\\alpha') self.assertEqual(str(a), "a") a.set_print_context('tex') self.assertEqual(str(a), "\\alpha") b = a-a+g.Pi b.set_print_context('tex') self.assertEqual(str(b), "\\pi") b.set_print_context('c') self.assertEqual(str(b), "Pi")
def testsimplify(self): i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("i"),3) A=g.symbol("A") B=g.symbol("B") C=g.symbol("C") sp=g.scalar_products() sp.add(A,B,0) sp.add(A,C,0) sp.add(A,A,4) e=g.indexed(A+B,i)*g.indexed(A+C,i) self.assertEqual(e.expand(g.expand_options.expand_indexed). simplify_indexed(sp),4+g.indexed(C,i)*g.indexed(B,i)) self.assertEqual(g.simplify_indexed(e.expand(g.expand_options. expand_indexed),sp),4+g.indexed(C,i)*g.indexed(B,i)) self.assertNotEqual(g.simplify_indexed(e.expand(g.expand_options. expand_indexed)),4+g.indexed(C,i)*g.indexed(B,i)) self.assertNotEqual(g.simplify_indexed(e.expand(g.expand_options. expand_indexed),sp),5+g.indexed(C,i)*g.indexed(B,i)) self.assertNotEqual(g.simplify_indexed(e.expand(g.expand_options. expand_indexed),sp),4+g.indexed(C,i)*g.indexed(B,j))
def testsymm(self): i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("j"),3) k=g.idx(g.symbol("k"),3) l=g.idx(g.symbol("l"),3) A=g.symbol("A") e=g.indexed(A,i,j) e=g.indexed(A,g.sy_none(), i,j) e=g.indexed(A,g.sy_none(0, 1), i,j) e=g.indexed(A,g.sy_none(g.symmetry(0), g.symmetry(1)), i,j) e=g.indexed(A,g.sy_symm(), i,j,k) e=g.indexed(A,g.sy_symm(0,1,2), i,j,k) e=g.indexed(A,g.sy_symm(2,0,1), i,j,k) e=g.indexed(A,g.sy_symm(0,1), i,j,k) e=g.indexed(A,g.sy_none(g.sy_symm(0,1),2), i,j,k) e=g.indexed(A,g.sy_anti(0,2), i,j,k) e=g.indexed(A,g.sy_none(g.sy_anti(0,2),1), i,j,k) e=g.indexed(A,g.sy_symm(g.sy_anti(0,1),g.sy_anti(2,3)), i,j,k,l) e=g.indexed(A,g.sy_cycl(), i,j,k) e=g.indexed(A,g.sy_cycl(0,1,2), i,j,k) #this is a deadlock... bug in ginac? #but nobody really needs that, so I don't care #g.sy_symm(0,1,2,3).add(4).add(5) e=g.indexed(A,g.sy_symm(),i,j)+g.indexed(A,g.sy_symm(),j,i) self.assertEqual(e,2*g.indexed(A,g.sy_symm(), i,j)) e=g.indexed(A,g.sy_anti(),i,j)+g.indexed(A,g.sy_anti(),j,i) self.assertEqual(e,0) e=g.indexed(A,g.sy_anti(),i,j,k)+g.indexed(A,g.sy_anti(),j,i,k) self.assertEqual(e,0)
def testmetric(self): mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4) rho=g.varidx(g.symbol("rho"),4) A=g.symbol("A") e=g.metric_tensor(mu,nu)*g.indexed(A,nu.toggle_variance(),rho) self.assertEqual(e.simplify_indexed(),g.indexed(A,mu,rho)) self.assertNotEqual(e.simplify_indexed(),g.indexed(A,nu,rho)) e=g.delta_tensor(mu,nu.toggle_variance())*g.metric_tensor(nu,rho) self.assertEqual(e.simplify_indexed(),g.metric_tensor(mu,rho)) e=g.metric_tensor(mu.toggle_variance(),nu.toggle_variance())*\ g.metric_tensor(nu,rho) self.assertEqual(e.simplify_indexed(), g.delta_tensor(mu.toggle_variance(),rho)) e=g.metric_tensor(nu.toggle_variance(),rho.toggle_variance())*\ g.metric_tensor(mu,nu)*(g.delta_tensor(mu.toggle_variance(),rho)+\ g.indexed(A,mu.toggle_variance(),rho)) self.assertEqual((e-(4+g.indexed(A,rho.toggle_variance(),rho))). simplify_indexed(),0)
def testdelta(self): i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("j"),3) k=g.idx(g.symbol("k"),3) l=g.idx(g.symbol("l"),3) A=g.symbol("A") B=g.symbol("B") e=g.indexed(A,i,j)*g.indexed(B,k,l)*g.delta_tensor(i,k)*\ g.delta_tensor(j,l) self.assertEqual((e-g.indexed(A,k,l)*g.indexed(B,k,l)). simplify_indexed(),0) self.assertEqual((e-g.indexed(B,k,l)*g.indexed(A,k,l)). simplify_indexed(),0) self.assertEqual((e-g.indexed(A,i,l)*g.indexed(B,i,l)). simplify_indexed(),0) self.assertEqual((e-g.indexed(A,i,j)*g.indexed(B,i,j)). simplify_indexed(),0) self.assertNotEqual((e-g.indexed(A,i,i)*g.indexed(B,k,k)). simplify_indexed(),0) self.assertEqual(g.delta_tensor(i,i),3) self.assertNotEqual(g.delta_tensor(i,i),4)
def __init__(self, name = 'x'): self.data = _g.symbol(name) self.spatial_symbs = [self.data] self.time = None
def test_autodoc(self): res = 0 x = g.symbol('x') if not (x.__doc__ == 'Proxy of C++ GiNaC::symbol class'): res += 1 self.assertEqual(res, 0)
ginac_routine = args.ginac_routine print 'Start preparing ' + file_name MyTestGenerator = TestGenerator() MyListCreator = listcreator.ListCreator() dirac_gamma = swiginac.dirac_gamma dirac_slash = swiginac.dirac_slash dirac_gamma5 = swiginac.dirac_gamma5 dirac_gammaR = swiginac.dirac_gammaR dirac_gammaL = swiginac.dirac_gammaL simplify_indexed = swiginac.simplify_indexed dirac_trace = swiginac.dirac_trace D = swiginac.symbol("D") i = swiginac.varidx(swiginac.symbol("i"), 4) j = swiginac.varidx(swiginac.symbol("j"), 4) k = swiginac.varidx(swiginac.symbol("k"), 4) l = swiginac.varidx(swiginac.symbol("l"), 4) m = swiginac.varidx(swiginac.symbol("m"), 4) n = swiginac.varidx(swiginac.symbol("n"), 4) o = swiginac.varidx(swiginac.symbol("o"), 4) p = swiginac.varidx(swiginac.symbol("p"), 4) iD = swiginac.varidx(swiginac.symbol("iD"), D) jD = swiginac.varidx(swiginac.symbol("jD"), D) kD = swiginac.varidx(swiginac.symbol("kD"), D) lD = swiginac.varidx(swiginac.symbol("lD"), D)
def testdummy(self): i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("j"),3) k=g.idx(g.symbol("k"),3) l=g.idx(g.symbol("l"),3) A=g.symbol("A") B=g.symbol("B") C=g.symbol("C") e=g.indexed(A,i,j)*g.indexed(B,j,k)+g.indexed(C,k,l,i,l) #can vary from run to run #self.assertEqual(str(e),"C.k.l.i.l+B.j.k*A.i.j") f=e.get_free_indices() self.failUnless(type(f)==list) self.failUnless(f==[i,k] or f==[k,i]) self.failUnless(str(f)=="[.i, .k]" or str(f)=="[.k, .i]") mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4) rho=g.varidx(g.symbol("rho"),4) sigma=g.varidx(g.symbol("sigma"),4) e=g.indexed(A,mu,nu)*g.indexed(B,nu.toggle_variance(),rho)+\ g.indexed(C,mu,sigma,rho,sigma.toggle_variance()) self.failUnless(e.get_free_indices()==[mu,rho] or e.get_free_indices()==[rho,mu]) e=g.indexed(A,mu,mu) self.assertEqual(e.get_free_indices(),[mu]) self.assertNotEqual(e.get_free_indices(),[mu.toggle_variance()])
def testeps(self): mu=g.varidx(g.symbol("mu"),4) nu=g.varidx(g.symbol("nu"),4) rho=g.varidx(g.symbol("rho"),4) sig=g.varidx(g.symbol("sig"),4) lam=g.varidx(g.symbol("lam"),4) bet=g.varidx(g.symbol("bet"),4) e=g.lorentz_eps(mu,nu,rho,sig)*g.lorentz_eps(mu.toggle_variance(), nu.toggle_variance(),lam,bet) g.simplify_indexed(e) i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("j"),3) k=g.idx(g.symbol("k"),3) A=g.symbol("A") B=g.symbol("B") e=g.epsilon_tensor(i,j,k)*g.indexed(A,j)*g.indexed(B,k) self.assertNotEqual(g.simplify_indexed(e),0) e=g.epsilon_tensor(i,j,k)*g.indexed(A,j)*g.indexed(A,k) self.assertEqual(g.simplify_indexed(e),0)
def testvaridx1(self): i=g.varidx(g.symbol("i"),3) j=g.varidx(g.symbol("j"),3) A=g.symbol("A") self.assertEqual(str(g.indexed(A,i,j)),"A~i~j")
# # If we initialize a set of symbols, we might want to use a loop rather than a # lot of lines with individual assignments. # # We can use the feature that the dictionary returned by the built-in function # `globals` can be manipulated # # >>> for name in ['gamma', 'delta', 'epsilon']: # ... globals()[name] = swiginac.symbol(name) # # To define the small latin letters a-z as symbols in this module, :: import string as _string for name in _string.lowercase: globals()[name] = swiginac.symbol(name) # Which results in # # >>> print type(delta), type(x) # <class 'swiginac.symbol'> <class 'swiginac.symbol'> # # # Numbers # ------- # # The ``numeric`` class can manipulate arbitrary precision integers in a very # fast way. # # Rational numbers are automatically converted to fractions of coprime # integers.
def testidx(self): i=g.idx(g.symbol("i"),3) j=g.idx(g.symbol("j"),3) A=g.symbol("A") self.assertEqual(str(g.indexed(A,i,j)),"A.i.j")