def test_powdenest_polar(): from sympy import powdenest x, y, z = symbols('x y z', polar=True) a, b, c = symbols('a b c') assert powdenest((x*y*z)**a) == x**a*y**a*z**a assert powdenest((x**a*y**b)**c) == x**(a*c)*y**(b*c) assert powdenest(((x**a)**b*y**c)**c) == x**(a*b*c)*y**(c**2)
def test_issue_2750(): I1, I2, I3, I4, I5, I6 = symbols('I1:7') dI1, dI4, dQ2, dQ4, Q2, Q4 = symbols('dI1,dI4,dQ2,dQ4,Q2,Q4') e = ( I1 - I2 - I3, I3 - I4 - I5, I4 + I5 - I6, -I1 + I2 + I6, -2*I1 - 2*I3 - 2*I5 - 3*I6 - dI1/2 + 12, -I4 + dQ4, -I2 + dQ2, 2*I3 + 2*I5 + 3*I6 - Q2, I4 - 2*I5 + 2*Q4 + dI4 ) ans = [{ dQ4: I3 - I5, dI1: -4*I2 - 8*I3 - 4*I5 - 6*I6 + 24, I4: I3 - I5, dQ2: I2, Q2: 2*I3 + 2*I5 + 3*I6, I1: I2 + I3, Q4: -I3/2 + 3*I5/2 - dI4/2}] assert solve(e, I1, I4, Q2, Q4, dI1, dI4, dQ2, dQ4, manual=True) == ans # the matrix solver (tested below) doesn't like this because it produces # a zero row in the matrix. Is this related to issue 1452? assert [ei.subs( ans[0]) for ei in e] == [0, 0, I3 - I6, -I3 + I6, 0, 0, 0, 0, 0]
def test_log_symbolic(): x, y = symbols('x,y') assert log(x, exp(1)) == log(x) assert log(exp(x)) != x assert log(x) == log(x) assert log(x, exp(1)) == log(x) assert log(x*y) != log(x) + log(y) assert log(x, 2) == log(x)/log(2) assert log(E, 2) == 1/log(2) p, q = symbols('p,q', positive=True) r = Symbol('r', real=True) assert log(p**2) != 2*log(p) assert log(p**2).expand() == 2*log(p) assert log(x**2).expand() != 2*log(x) assert log(p**q) != q*log(p) assert log(exp(p)) == p assert log(p*q) != log(p) + log(q) assert log(p*q).expand() == log(p) + log(q) assert log(-exp(p)) != p + I*pi assert log(-exp(x)).expand() != x + I*pi assert log(-exp(r)).expand() == r + I*pi assert log(x**y) != y*log(x) assert (log(x**-5)**-1).expand() != -1/log(x)/5 assert (log(p**-5)**-1).expand() == -1/log(p)/5 assert log(-x).func is log and log(-x).args[0] == -x assert log(-p).func is log and log(-p).args[0] == -p
def test_subs_dict(): a, b, c, d, e = symbols('a b c d e') z = symbols('z') assert (2*x + y + z).subs(dict(x=1, y=2)) == 4 + z l = [(sin(x), 2), (x, 1)] assert (sin(x)).subs(l) == \ (sin(x)).subs(dict(l)) == 2 assert sin(x).subs(reversed(l)) == sin(1) expr = sin(2*x) + sqrt(sin(2*x))*cos(2*x)*sin(exp(x)*x) reps = dict([ (sin(2*x), c), (sqrt(sin(2*x)), a), (cos(2*x), b), (exp(x), e), (x, d), ]) assert expr.subs(reps) == c + a*b*sin(d*e) l = [(x, 3), (y, x**2)] assert (x + y).subs(l) == 3 + x**2 assert (x + y).subs(reversed(l)) == 12 # If changes are made to convert lists into dictionaries and do # a dictionary-lookup replacement, these tests will help to catch # some logical errors that might occur l = [(y, z + 2), (1 + z, 5), (z, 2)] assert (y - 1 + 3*x).subs(l) == 5 + 3*x l = [(y, z + 2), (z, 3)] assert (y - 2).subs(l) == 3
def test_exclude(): R, C, Ri, Vout, V1, Vminus, Vplus, s = \ symbols('R, C, Ri, Vout, V1, Vminus, Vplus, s') Rf = symbols('Rf', positive=True) # to eliminate Rf = 0 soln eqs = [C*V1*s + Vplus*(-2*C*s - 1/R), Vminus*(-1/Ri - 1/Rf) + Vout/Rf, C*Vplus*s + V1*(-C*s - 1/R) + Vout/R, -Vminus + Vplus] assert solve(eqs, exclude=s*C*R) == [ { Rf: Ri*(C*R*s + 1)**2/(C*R*s), Vminus: Vplus, V1: Vplus*(2*C*R*s + 1)/(C*R*s), Vout: Vplus*(C**2*R**2*s**2 + 3*C*R*s + 1)/(C*R*s)}, { Vplus: 0, Vminus: 0, V1: 0, Vout: 0}, ] assert solve(eqs, exclude=[Vplus, s, C]) == [ { Rf: Ri*(V1 - Vplus)**2/(Vplus*(V1 - 2*Vplus)), Vminus: Vplus, Vout: (V1**2 - V1*Vplus - Vplus**2)/(V1 - 2*Vplus), R: Vplus/(C*s*(V1 - 2*Vplus))}]
def eq_sympy(input_dim, output_dim, ARD=False): """ Latent force model covariance, exponentiated quadratic with multiple outputs. Derived from a diffusion equation with the initial spatial condition layed down by a Gaussian process with lengthscale given by shared_lengthscale. See IEEE Trans Pattern Anal Mach Intell. 2013 Nov;35(11):2693-705. doi: 10.1109/TPAMI.2013.86. Linear latent force models using Gaussian processes. Alvarez MA, Luengo D, Lawrence ND. :param input_dim: Dimensionality of the kernel :type input_dim: int :param output_dim: number of outputs in the covariance function. :type output_dim: int :param ARD: whether or not to user ARD (default False). :type ARD: bool """ real_input_dim = input_dim if output_dim>1: real_input_dim -= 1 X = sp.symbols('x_:' + str(real_input_dim)) Z = sp.symbols('z_:' + str(real_input_dim)) scale = sp.var('scale_i scale_j',positive=True) if ARD: lengthscales = [sp.var('lengthscale%i_i lengthscale%i_j' % i, positive=True) for i in range(real_input_dim)] shared_lengthscales = [sp.var('shared_lengthscale%i' % i, positive=True) for i in range(real_input_dim)] dist_string = ' + '.join(['(x_%i-z_%i)**2/(shared_lengthscale%i**2 + lengthscale%i_i**2 + lengthscale%i_j**2)' % (i, i, i) for i in range(real_input_dim)]) dist = parse_expr(dist_string) f = variance*sp.exp(-dist/2.) else: lengthscales = sp.var('lengthscale_i lengthscale_j',positive=True) shared_lengthscale = sp.var('shared_lengthscale',positive=True) dist_string = ' + '.join(['(x_%i-z_%i)**2' % (i, i) for i in range(real_input_dim)]) dist = parse_expr(dist_string) f = scale_i*scale_j*sp.exp(-dist/(2*(lengthscale_i**2 + lengthscale_j**2 + shared_lengthscale**2))) return kern(input_dim, [spkern(input_dim, f, output_dim=output_dim, name='eq_sympy')])
def test_issue_6966(): i, k, m = symbols('i k m', integer=True) z_i, q_i = symbols('z_i q_i') a_k = Sum(-q_i*z_i/k,(i,1,m)) b_k = a_k.diff(z_i) assert isinstance(b_k, Sum) assert b_k == Sum(-q_i/k,(i,1,m))
def test_adjoint(): a = Symbol('a', antihermitian=True) b = Symbol('b', hermitian=True) assert adjoint(a) == -a assert adjoint(I*a) == I*a assert adjoint(b) == b assert adjoint(I*b) == -I*b assert adjoint(a*b) == -b*a assert adjoint(I*a*b) == I*b*a x, y = symbols('x y') assert adjoint(adjoint(x)) == x assert adjoint(x + y) == adjoint(x) + adjoint(y) assert adjoint(x - y) == adjoint(x) - adjoint(y) assert adjoint(x * y) == adjoint(x) * adjoint(y) assert adjoint(x / y) == adjoint(x) / adjoint(y) assert adjoint(-x) == -adjoint(x) x, y = symbols('x y', commutative=False) assert adjoint(adjoint(x)) == x assert adjoint(x + y) == adjoint(x) + adjoint(y) assert adjoint(x - y) == adjoint(x) - adjoint(y) assert adjoint(x * y) == adjoint(y) * adjoint(x) assert adjoint(x / y) == 1 / adjoint(y) * adjoint(x) assert adjoint(-x) == -adjoint(x)
def test_is_constant(): from sympy.solvers.solvers import checksol Sum(x, (x, 1, 10)).is_constant() == True Sum(x, (x, 1, n)).is_constant() == False Sum(x, (x, 1, n)).is_constant(y) == True Sum(x, (x, 1, n)).is_constant(n) == False Sum(x, (x, 1, n)).is_constant(x) == True eq = a * cos(x) ** 2 + a * sin(x) ** 2 - a eq.is_constant() == True assert eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0 assert x.is_constant() is False assert x.is_constant(y) is True assert checksol(x, x, Sum(x, (x, 1, n))) == False assert checksol(x, x, Sum(x, (x, 1, n))) == False f = Function("f") assert checksol(x, x, f(x)) == False p = symbols("p", positive=True) assert Pow(x, S(0), evaluate=False).is_constant() == True # == 1 assert Pow(S(0), x, evaluate=False).is_constant() == False # == 0 or 1 assert Pow(S(0), p, evaluate=False).is_constant() == True # == 1 assert (2 ** x).is_constant() == False assert Pow(S(2), S(3), evaluate=False).is_constant() == True z1, z2 = symbols("z1 z2", zero=True) assert (z1 + 2 * z2).is_constant() is True assert meter.is_constant() is True assert (3 * meter).is_constant() is True assert (x * meter).is_constant() is False
def test_issue_11230(): # a specific test that always failed a, b, f, k, l, i = symbols('a b f k l i') p = [a*b*f*k*l, a*i*k**2*l, f*i*k**2*l] R, C = cse(p) assert not any(i.is_Mul for a in C for i in a.args) # random tests for the issue from random import choice from sympy.core.function import expand_mul s = symbols('a:m') # 35 Mul tests, none of which should ever fail ex = [Mul(*[choice(s) for i in range(5)]) for i in range(7)] for p in subsets(ex, 3): p = list(p) R, C = cse(p) assert not any(i.is_Mul for a in C for i in a.args) for ri in reversed(R): for i in range(len(C)): C[i] = C[i].subs(*ri) assert p == C # 35 Add tests, none of which should ever fail ex = [Add(*[choice(s[:7]) for i in range(5)]) for i in range(7)] for p in subsets(ex, 3): p = list(p) was = R, C = cse(p) assert not any(i.is_Add for a in C for i in a.args) for ri in reversed(R): for i in range(len(C)): C[i] = C[i].subs(*ri) # use expand_mul to handle cases like this: # p = [a + 2*b + 2*e, 2*b + c + 2*e, b + 2*c + 2*g] # x0 = 2*(b + e) is identified giving a rebuilt p that # is now `[a + 2*(b + e), c + 2*(b + e), b + 2*c + 2*g]` assert p == [expand_mul(i) for i in C]
def test_as_real_imag(): n = pi**1000 # the special code for working out the real # and complex parts of a power with Integer exponent # should not run if there is no imaginary part, hence # this should not hang assert n.as_real_imag() == (n, 0) # issue 6261 x = Symbol('x') assert sqrt(x).as_real_imag() == \ ((re(x)**2 + im(x)**2)**(S(1)/4)*cos(atan2(im(x), re(x))/2), (re(x)**2 + im(x)**2)**(S(1)/4)*sin(atan2(im(x), re(x))/2)) # issue 3853 a, b = symbols('a,b', real=True) assert ((1 + sqrt(a + b*I))/2).as_real_imag() == \ ( (a**2 + b**2)**Rational( 1, 4)*cos(atan2(b, a)/2)/2 + Rational(1, 2), (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)/2) assert sqrt(a**2).as_real_imag() == (sqrt(a**2), 0) i = symbols('i', imaginary=True) assert sqrt(i**2).as_real_imag() == (0, abs(i))
def test_logcombine_1(): x, y = symbols("x,y") a = Symbol("a") z, w = symbols("z,w", positive=True) b = Symbol("b", real=True) assert logcombine(log(x) + 2*log(y)) == log(x) + 2*log(y) assert logcombine(log(x) + 2*log(y), force=True) == log(x*y**2) assert logcombine(a*log(w) + log(z)) == a*log(w) + log(z) assert logcombine(b*log(z) + b*log(x)) == log(z**b) + b*log(x) assert logcombine(b*log(z) - log(w)) == log(z**b/w) assert logcombine(log(x)*log(z)) == log(x)*log(z) assert logcombine(log(w)*log(x)) == log(w)*log(x) assert logcombine(cos(-2*log(z) + b*log(w))) in [cos(log(w**b/z**2)), cos(log(z**2/w**b))] assert logcombine(log(log(x) - log(y)) - log(z), force=True) == \ log(log(x/y)/z) assert logcombine((2 + I)*log(x), force=True) == (2 + I)*log(x) assert logcombine((x**2 + log(x) - log(y))/(x*y), force=True) == \ (x**2 + log(x/y))/(x*y) # the following could also give log(z*x**log(y**2)), what we # are testing is that a canonical result is obtained assert logcombine(log(x)*2*log(y) + log(z), force=True) == \ log(z*y**log(x**2)) assert logcombine((x*y + sqrt(x**4 + y**4) + log(x) - log(y))/(pi*x**Rational(2, 3)* sqrt(y)**3), force=True) == ( x*y + sqrt(x**4 + y**4) + log(x/y))/(pi*x**(S(2)/3)*y**(S(3)/2)) assert logcombine(gamma(-log(x/y))*acos(-log(x/y)), force=True) == \ acos(-log(x/y))*gamma(-log(x/y)) assert logcombine(2*log(z)*log(w)*log(x) + log(z) + log(w)) == \ log(z**log(w**2))*log(x) + log(w*z) assert logcombine(3*log(w) + 3*log(z)) == log(w**3*z**3) assert logcombine(x*(y + 1) + log(2) + log(3)) == x*(y + 1) + log(6) assert logcombine((x + y)*log(w) + (-x - y)*log(3)) == (x + y)*log(w/3)
def test_issue_1572_1364_1368(): assert solve((sqrt(x**2 - 1) - 2)) in ([sqrt(5), -sqrt(5)], [-sqrt(5), sqrt(5)]) assert solve((2**exp(y**2/x) + 2)/(x**2 + 15), y) == ( [-sqrt(x)*sqrt(log((log(2) + I*pi)/log(2))), sqrt(x)*sqrt(log((log(2) + I*pi)/log(2)))] ) C1, C2 = symbols('C1 C2') f = Function('f') assert solve(C1 + C2/x**2 - exp(-f(x)), f(x)) == [log(x**2/(C1*x**2 + C2))] a = symbols('a') E = S.Exp1 assert solve(1 - log(a + 4*x**2), x) in ( [-sqrt(-a + E)/2, sqrt(-a + E)/2], [sqrt(-a + E)/2, -sqrt(-a + E)/2] ) assert solve(log(a**(-3) - x**2)/a, x) in ( [-sqrt(-1 + a**(-3)), sqrt(-1 + a**(-3))], [sqrt(-1 + a**(-3)), -sqrt(-1 + a**(-3))],) assert solve(1 - log(a + 4*x**2), x) in ( [-sqrt(-a + E)/2, sqrt(-a + E)/2], [sqrt(-a + E)/2, -sqrt(-a + E)/2],) assert solve((a**2 + 1) * (sin(a*x) + cos(a*x)), x) == [-pi/(4*a), 3*pi/(4*a)] assert solve(3 - (sinh(a*x) + cosh(a*x)), x) == [2*atanh(S.Half)/a] assert solve(3-(sinh(a*x) + cosh(a*x)**2), x) == \ [ 2*atanh(-1 + sqrt(2))/a, 2*atanh(S(1)/2 + sqrt(5)/2)/a, 2*atanh(-sqrt(2) - 1)/a, 2*atanh(-sqrt(5)/2 + S(1)/2)/a ] assert solve(atan(x) - 1) == [tan(1)]
def test_manualintegrate_orthogonal_poly(): n = symbols('n') a, b = 7, S(5)/3 polys = [jacobi(n, a, b, x), gegenbauer(n, a, x), chebyshevt(n, x), chebyshevu(n, x), legendre(n, x), hermite(n, x), laguerre(n, x), assoc_laguerre(n, a, x)] for p in polys: integral = manualintegrate(p, x) for deg in [-2, -1, 0, 1, 3, 5, 8]: # some accept negative "degree", some do not try: p_subbed = p.subs(n, deg) except ValueError: continue assert (integral.subs(n, deg).diff(x) - p_subbed).expand() == 0 # can also integrate simple expressions with these polynomials q = x*p.subs(x, 2*x + 1) integral = manualintegrate(q, x) for deg in [2, 4, 7]: assert (integral.subs(n, deg).diff(x) - q.subs(n, deg)).expand() == 0 # cannot integrate with respect to any other parameter t = symbols('t') for i in range(len(p.args) - 1): new_args = list(p.args) new_args[i] = t assert isinstance(manualintegrate(p.func(*new_args), t), Integral)
def test_case(): ob = FCodePrinter() x,x_,x__,y,X,X_,Y = symbols('x,x_,x__,y,X,X_,Y') assert fcode(exp(x_) + sin(x*y) + cos(X*Y)) == \ ' exp(x_) + sin(x*y) + cos(X__*Y_)' assert fcode(exp(x__) + 2*x*Y*X_**Rational(7, 2)) == \ ' 2*X_**(7.0d0/2.0d0)*Y*x + exp(x__)' assert fcode(exp(x_) + sin(x*y) + cos(X*Y), name_mangling=False) == \ ' exp(x_) + sin(x*y) + cos(X*Y)' assert fcode(x - cos(X), name_mangling=False) == ' x - cos(X)' assert ob.doprint(X*sin(x) + x_, assign_to='me') == ' me = X*sin(x_) + x__' assert ob.doprint(X*sin(x), assign_to='mu') == ' mu = X*sin(x_)' assert ob.doprint(x_, assign_to='ad') == ' ad = x__' n, m = symbols('n,m', integer=True) A = IndexedBase('A') x = IndexedBase('x') y = IndexedBase('y') i = Idx('i', m) I = Idx('I', n) assert fcode(A[i, I]*x[I], assign_to=y[i], source_format='free') == ( "do i = 1, m\n" " y(i) = 0\n" "end do\n" "do i = 1, m\n" " do I_ = 1, n\n" " y(i) = A(i, I_)*x(I_) + y(i)\n" " end do\n" "end do" )
def Simple_manifold_with_scalar_function_derivative(): Print_Function() coords = (x,y,z) = symbols('x y z') basis = (e1, e2, e3, grad) = MV.setup('e_1 e_2 e_3',metric='[1,1,1]',coords=coords) # Define surface mfvar = (u,v) = symbols('u v') X = u*e1+v*e2+(u**2+v**2)*e3 print '\\f{X}{u,v} =',X MF = Manifold(X,mfvar) (eu,ev) = MF.Basis() # Define field on the surface. g = (v+1)*log(u) print '\\f{g}{u,v} =',g # Method 1: Using old Manifold routines. VectorDerivative = (MF.rbasis[0]/MF.E_sq)*diff(g,u) + (MF.rbasis[1]/MF.E_sq)*diff(g,v) print '\\eval{\\nabla g}{u=1,v=0} =', VectorDerivative.subs({u:1,v:0}) # Method 2: Using new Manifold routines. dg = MF.Grad(g) print '\\eval{\\f{Grad}{g}}{u=1,v=0} =', dg.subs({u:1,v:0}) dg = MF.grad*g print '\\eval{\\nabla g}{u=1,v=0} =', dg.subs({u:1,v:0}) return
def Test_Reciprocal_Frame(): Print_Function() Format() coords = symbols('x y z') (ex,ey,ez,grad) = MV.setup('e_x e_y e_z',metric='[1,1,1]',coords=coords) mfvar = (u,v) = symbols('u v') eu = ex+ey ev = ex-ey (eu_r,ev_r) = ReciprocalFrame([eu,ev]) oprint('\\mbox{Frame}',(eu,ev),'\\mbox{Reciprocal Frame}',(eu_r,ev_r)) print r'%\bm{e}_{u}\cdot\bm{e}^{u} =',(eu|eu_r) print r'%\bm{e}_{u}\cdot\bm{e}^{v} =',eu|ev_r print r'%\bm{e}_{v}\cdot\bm{e}^{u} =',ev|eu_r print r'%\bm{e}_{v}\cdot\bm{e}^{v} =',ev|ev_r eu = ex+ey+ez ev = ex-ey (eu_r,ev_r) = ReciprocalFrame([eu,ev]) oprint('\\mbox{Frame}',(eu,ev),'\\mbox{Reciprocal Frame}',(eu_r,ev_r)) print r'%\bm{e}_{u}\cdot\bm{e}^{u} =',eu|eu_r print r'%\bm{e}_{u}\cdot\bm{e}^{v} =',eu|ev_r print r'%\bm{e}_{v}\cdot\bm{e}^{u} =',ev|eu_r print r'%\bm{e}_{v}\cdot\bm{e}^{v} =',ev|ev_r return
def Simple_manifold_with_vector_function_derivative(): Print_Function() coords = (x,y,z) = symbols('x y z') basis = (ex, ey, ez, grad) = \ MV.setup('e_x e_y e_z',metric='[1,1,1]',coords=coords) # Define surface mfvar = (u,v) = symbols('u v') X = u*ex+v*ey+(u**2+v**2)*ez print '\\f{X}{u,v} =',X MF = Manifold(X,mfvar) (eu,ev) = MF.Basis() # Define field on the surface. g = (v+1)*log(u) print '\\mbox{Scalar Function: } g =',g dg = MF.grad*g dg.Fmt(3,'\\mbox{Scalar Function Derivative: } \\nabla g') print '\\eval{\\nabla g}{(1,0)} =',dg.subs({u:1,v:0}) # Define vector field on the surface G = v**2*eu+u**2*ev print '\\mbox{Vector Function: } G =',G dG = MF.grad*G dG.Fmt(3,'\\mbox{Vector Function Derivative: } \\nabla G') print '\\eval{\\nabla G}{(1,0)} =',dG.subs({u:1,v:0}) return
def Distorted_manifold_with_scalar_function(): Print_Function() coords = symbols('x y z') (ex,ey,ez,grad) = MV.setup('e_x e_y e_z',metric='[1,1,1]',coords=coords) mfvar = (u,v) = symbols('u v') X = 2*u*ex+2*v*ey+(u**3+v**3/2)*ez MF = Manifold(X,mfvar,I=MV.i) (eu,ev) = MF.Basis() g = (v+1)*log(u) dg = MF.Grad(g) print 'g =',g print 'dg =',dg print '\\eval{dg}{u=1,v=0} =',dg.subs({u:1,v:0}) G = u*eu+v*ev dG = MF.Grad(G) print 'G =',G print 'P(G) =',MF.Proj(G) print 'dG =',dG print 'P(dG) =',MF.Proj(dG) PS = u*v*eu^ev print 'P(S) =',PS print 'dP(S) =',MF.Grad(PS) print 'P(dP(S)) =',MF.Proj(MF.Grad(PS)) return
def test_fraction(): x, y, z = map(Symbol, 'xyz') A = Symbol('A', commutative=False) assert fraction(Rational(1, 2)) == (1, 2) assert fraction(x) == (x, 1) assert fraction(1/x) == (1, x) assert fraction(x/y) == (x, y) assert fraction(x/2) == (x, 2) assert fraction(x*y/z) == (x*y, z) assert fraction(x/(y*z)) == (x, y*z) assert fraction(1/y**2) == (1, y**2) assert fraction(x/y**2) == (x, y**2) assert fraction((x**2 + 1)/y) == (x**2 + 1, y) assert fraction(x*(y + 1)/y**7) == (x*(y + 1), y**7) assert fraction(exp(-x), exact=True) == (exp(-x), 1) assert fraction((1/(x + y))/2, exact=True) == (1, Mul(2,(x + y), evaluate=False)) assert fraction(x*A/y) == (x*A, y) assert fraction(x*A**-1/y) == (x*A**-1, y) n = symbols('n', negative=True) assert fraction(exp(n)) == (1, exp(-n)) assert fraction(exp(-n)) == (exp(-n), 1) p = symbols('p', positive=True) assert fraction(exp(-p)*log(p), exact=True) == (exp(-p)*log(p), 1)
def test_mellin_transform_fail(): skip("Risch takes forever.") from sympy import Max, Min MT = mellin_transform bpos = symbols('b', positive=True) bneg = symbols('b', negative=True) expr = (sqrt(x + b**2) + b)**a/sqrt(x + b**2) # TODO does not work with bneg, argument wrong. Needs changes to matching. assert MT(expr.subs(b, -bpos), x, s) == \ ((-1)**(a + 1)*2**(a + 2*s)*bpos**(a + 2*s - 1)*gamma(a + s) *gamma(1 - a - 2*s)/gamma(1 - s), (-re(a), -re(a)/2 + S(1)/2), True) expr = (sqrt(x + b**2) + b)**a assert MT(expr.subs(b, -bpos), x, s) == \ ( 2**(a + 2*s)*a*bpos**(a + 2*s)*gamma(-a - 2* s)*gamma(a + s)/gamma(-s + 1), (-re(a), -re(a)/2), True) # Test exponent 1: assert MT(expr.subs({b: -bpos, a: 1}), x, s) == \ (-bpos**(2*s + 1)*gamma(s)*gamma(-s - S(1)/2)/(2*sqrt(pi)), (-1, -S(1)/2), True)
def test_take(): X = numbered_symbols() assert take(X, 5) == list(symbols('x0:5')) assert take(X, 5) == list(symbols('x5:10')) assert take([1, 2, 3, 4, 5], 5) == [1, 2, 3, 4, 5]
def test_order_could_be_zero(): x, y = symbols('x, y') n = symbols('n', integer=True, nonnegative=True) m = symbols('m', integer=True, positive=True) assert diff(y, (x, n)) == Piecewise((y, Eq(n, 0)), (0, True)) assert diff(y, (x, n + 1)) == S.Zero assert diff(y, (x, m)) == S.Zero
def test_mul_noncommutative(): x, y = symbols('x y') A, B = symbols('A B', commutative=False) u, v = symbols('u v', cls=Wild) w = Wild('w', commutative=False) assert (u*v).matches(x) in ({v: x, u: 1}, {u: x, v: 1}) assert (u*v).matches(x*y) in ({v: y, u: x}, {u: y, v: x}) assert (u*v).matches(A) is None assert (u*v).matches(A*B) is None assert (u*v).matches(x*A) is None assert (u*v).matches(x*y*A) is None assert (u*v).matches(x*A*B) is None assert (u*v).matches(x*y*A*B) is None assert (v*w).matches(x) is None assert (v*w).matches(x*y) is None assert (v*w).matches(A) == {w: A, v: 1} assert (v*w).matches(A*B) == {w: A*B, v: 1} assert (v*w).matches(x*A) == {w: A, v: x} assert (v*w).matches(x*y*A) == {w: A, v: x*y} assert (v*w).matches(x*A*B) == {w: A*B, v: x} assert (v*w).matches(x*y*A*B) == {w: A*B, v: x*y} assert (v*w).matches(-x) is None assert (v*w).matches(-x*y) is None assert (v*w).matches(-A) == {w: A, v: -1} assert (v*w).matches(-A*B) == {w: A*B, v: -1} assert (v*w).matches(-x*A) == {w: A, v: -x} assert (v*w).matches(-x*y*A) == {w: A, v: -x*y} assert (v*w).matches(-x*A*B) == {w: A*B, v: -x} assert (v*w).matches(-x*y*A*B) == {w: A*B, v: -x*y}
def test_symarray(): """Test creation of numpy arrays of sympy symbols.""" import numpy as np import numpy.testing as npt syms = symbols('_0 _1 _2') s1 = symarray(3) s2 = symarray(3) npt.assert_array_equal (s1, np.array(syms, dtype=object)) assert s1[0] is s2[0] a = symarray(3, 'a') b = symarray(3, 'b') assert not(a[0] is b[0]) asyms = symbols('a_0 a_1 a_2') npt.assert_array_equal (a, np.array(asyms, dtype=object)) # Multidimensional checks a2d = symarray((2,3), 'a') assert a2d.shape == (2,3) a00, a12 = symbols('a_0_0, a_1_2') assert a2d[0,0] is a00 assert a2d[1,2] is a12 a3d = symarray((2,3,2), 'a') assert a3d.shape == (2,3,2) a000, a120, a121 = symbols('a_0_0_0, a_1_2_0 a_1_2_1') assert a3d[0,0,0] is a000 assert a3d[1,2,0] is a120 assert a3d[1,2,1] is a121
def test_pde_separate_mul(): x, y, z, t = symbols("x,y,z,t") c = Symbol("C", real=True) Phi = Function("Phi") F, R, T, X, Y, Z, u = map(Function, "FRTXYZu") r, theta, z = symbols("r,theta,z") # Something simple :) eq = Eq(D(F(x, y, z), x) + D(F(x, y, z), y) + D(F(x, y, z), z)) # Duplicate arguments in functions raises(ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), u(z, z)])) # Wrong number of arguments raises(ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), Y(y)])) # Wrong variables: [x, y] -> [x, z] raises(ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(t), Y(x, y)])) assert pde_separate_mul(eq, F(x, y, z), [Y(y), u(x, z)]) == [ D(Y(y), y) / Y(y), -D(u(x, z), x) / u(x, z) - D(u(x, z), z) / u(x, z), ] assert pde_separate_mul(eq, F(x, y, z), [X(x), Y(y), Z(z)]) == [ D(X(x), x) / X(x), -D(Z(z), z) / Z(z) - D(Y(y), y) / Y(y), ] # wave equation wave = Eq(D(u(x, t), t, t), c ** 2 * D(u(x, t), x, x)) res = pde_separate_mul(wave, u(x, t), [X(x), T(t)]) assert res == [D(X(x), x, x) / X(x), D(T(t), t, t) / (c ** 2 * T(t))] # Laplace equation in cylindrical coords eq = Eq( 1 / r * D(Phi(r, theta, z), r) + D(Phi(r, theta, z), r, 2) + 1 / r ** 2 * D(Phi(r, theta, z), theta, 2) + D(Phi(r, theta, z), z, 2) ) # Separate z res = pde_separate_mul(eq, Phi(r, theta, z), [Z(z), u(theta, r)]) assert res == [ D(Z(z), z, z) / Z(z), -D(u(theta, r), r, r) / u(theta, r) - D(u(theta, r), r) / (r * u(theta, r)) - D(u(theta, r), theta, theta) / (r ** 2 * u(theta, r)), ] # Lets use the result to create a new equation... eq = Eq(res[1], c) # ...and separate theta... res = pde_separate_mul(eq, u(theta, r), [T(theta), R(r)]) assert res == [ D(T(theta), theta, theta) / T(theta), -r * D(R(r), r) / R(r) - r ** 2 * D(R(r), r, r) / R(r) - c * r ** 2, ] # ...or r... res = pde_separate_mul(eq, u(theta, r), [R(r), T(theta)]) assert res == [ r * D(R(r), r) / R(r) + r ** 2 * D(R(r), r, r) / R(r) + c * r ** 2, -D(T(theta), theta, theta) / T(theta), ]
def test_as_numer_denom(): assert oo.as_numer_denom() == (1, 0) assert (-oo).as_numer_denom() == (-1, 0) assert zoo.as_numer_denom() == (zoo, 1) assert (-zoo).as_numer_denom() == (zoo, 1) assert x.as_numer_denom() == (x, 1) assert (1/x).as_numer_denom() == (1, x) assert (x/y).as_numer_denom() == (x, y) assert (x/2).as_numer_denom() == (x, 2) assert (x*y/z).as_numer_denom() == (x*y, z) assert (x/(y*z)).as_numer_denom() == (x, y*z) assert Rational(1, 2).as_numer_denom() == (1, 2) assert (1/y**2).as_numer_denom() == (1, y**2) assert (x/y**2).as_numer_denom() == (x, y**2) assert ((x**2+1)/y).as_numer_denom() == (x**2+1, y) assert (x*(y+1)/y**7).as_numer_denom() == (x*(y+1), y**7) assert (x**-2).as_numer_denom() == (1, x**2) n = symbols('n', negative=True) assert (x**n).as_numer_denom() == (x**n, 1) assert sqrt(1/n).as_numer_denom() == (I, sqrt(-n)) n = Symbol('0 or neg', nonpositive=True) assert ((x/n)**-S.Half).as_numer_denom() == (1, (x/n)**S.Half) A, B, C = symbols('A,B,C', commutative=False) assert (A*B*C**-1).as_numer_denom() == (A*B*C**-1, 1) assert (A*B*C**-1/x).as_numer_denom() == (A*B*C**-1, x) assert (C**-1*A*B).as_numer_denom() == (C**-1*A*B, 1) assert (C**-1*A*B/x).as_numer_denom() == (C**-1*A*B, x) assert ((A*B*C)**-1).as_numer_denom() == ((A*B*C)**-1, 1) assert ((A*B*C)**-1/x).as_numer_denom() == ((A*B*C)**-1, x)
def test_issue_9699(): n, k = symbols('n k', real=True) x, y = symbols('x, y') assert combsimp((n + 1)*factorial(n)) == factorial(n + 1) assert combsimp((x + 1)*factorial(x)/gamma(y)) == gamma(x + 2)/gamma(y) assert combsimp(factorial(n)/n) == factorial(n - 1) assert combsimp(rf(x + n, k)*binomial(n, k)) == binomial(n, k)*gamma(k + n + x)/gamma(n + x)
def integra(self,A,l,momentum,mass): #returns regularized integral div=self.div_facets(alpha=A) #print(div) if len(div)==0: d=sympy.symbols("K"+str(A).replace(",","").replace(" ", "_").replace("]", "+e]" )) return d result=0 facet=div[-1] not_on_facet_index= where(self.lattice_points().dot(facet)>0) not_on_facet=self.lattice_points()[not_on_facet_index] # print(not_on_facet,len(not_on_facet)) if facet.dot(A)==0: # print(facet[-1]) e=(sympy.symbols("e")**(-1) )* (sympy.Rational(1,int(facet[-1]))) else: e=facet.dot(A)**(-1) for x in not_on_facet: result= sympy.Add(result,(A[-1]+sympy.symbols("e"))*e*self.coef_of_cut(x[:-1],l,mass,momentum)*(int(facet.dot(x)))*(self.integra(A+x,l,momentum,mass))) return result
def gen_model(self): self.x = sympy.symbols(self.model['var']) self.p = sympy.symbols(self.model['par']) local_dict = {} for x in self.x: local_dict[x.name] = x for p in self.p: local_dict[p.name] = p self.ode = [] for e in self.model['ode']: self.ode.append(sympy.parsing.sympy_parser.parse_expr(e, local_dict = local_dict)) self.dim = len(self.ode) self.pv = [] self.pc = [] #cont = self.model['cont'].split(' ') cont = self.model['cont'] self.npar = len(cont) for c in cont: for p in self.p: if p.name == c: self.pv.append(p) break for p in self.p: if p.name not in cont: self.pc.append(p) self.pinit = {} self.xinit = {} for p in self.p: if p.name in self.model: self.pinit[p.name] = self.model[p.name] else: raise RuntimeError('Init value for parameter %s not set' % p.name) for x in self.x: self.xinit[x.name] = self.model.get(x.name, 0.0)
def test_Function_subs(): from sympy.abc import x, y f, g, h, i = symbols('f g h i', cls=Function) p = Piecewise((g(f(x, y)), x < -1), (g(x), x <= 1)) assert p.subs(g, h) == Piecewise((h(f(x, y)), x < -1), (h(x), x <= 1)) assert (f(y) + g(x)).subs({f: h, g: i}) == i(x) + h(y)
def test_unit_propagate(): A, B, C = symbols('A,B,C') assert unit_propagate([A | B], A) == [] assert unit_propagate([A | B, ~A | C, ~C | B, A], A) == [C, ~C | B, A]
def test_propKB_tolerant(): """"tolerant to bad input""" kb = PropKB() A, B, C = symbols('A,B,C') assert kb.ask(B) is False
def test_entails(): A, B, C = symbols('A, B, C') assert entails(A, [A >> B, ~B]) is False assert entails(B, [Equivalent(A, B), A]) is True assert entails((A >> B) >> (~A >> ~B)) is False assert entails((A >> B) >> (~B >> ~A)) is True
def test_literal(): A, B = symbols('A,B') assert literal_symbol(True) is True assert literal_symbol(False) is False assert literal_symbol(A) is A assert literal_symbol(~A) is A
def test_satisfiable(): A, B, C = symbols('A,B,C') assert satisfiable(A & (A >> B) & ~B) is False
def test_noncommutative_subs(): x, y = symbols('x,y', commutative=False) assert (x * y * x).subs([(x, x * y), (y, x)], simultaneous=True) == (x * y * x**2 * y)
from sympy import symbols, cos, sin, pi, simplify, sqrt, atan2 from sympy.matrices import Matrix # Create joint variable symbols. q1, q2, q3, q4, q5, q6, q7 = symbols('q1:8') d1, d2, d3, d4, d5, d6, d7 = symbols('d1:8') a0, a1, a2, a3, a4, a5, a6 = symbols('a0:7') alpha0, alpha1, alpha2, alpha3, alpha4, alpha5, alpha6 = symbols('alpha0:7') # Denavit-Hartenberg parameter values. s = { alpha0: 0, a0: 0, d1: 0.75, alpha1: -pi / 2, a1: 0.35, d2: 0, q2: q2 - pi / 2, alpha2: 0, a2: 1.25, d3: 0, alpha3: -pi / 2, a3: -0.054, d4: 1.5, alpha4: pi / 2, a4: 0, d5: 0, alpha5: -pi / 2, a5: 0, d6: 0, alpha6: 0,
u(x=2\pi, y) &= u(x=0, y) \\ g(x=2\pi, y) &= g(x=0, y) We use a Tensorproductspace with Fourier expansions in the x-direction and a composite Chebyshev or Legendre basis in the y-direction for ``u``, whereas a regular Chebyshev or Legendre basis is used for ``g``. The equations are solved coupled and implicit. """ import os import numpy as np from sympy import symbols, sin, cos from shenfun import * x, y, z = symbols("x,y,z", real=True) #ue = (sin(2*x)*cos(3*y))*(1-x**2) ue = (sin(4*x)*cos(5*y)*sin(4*z))*(1-z**2) dux = ue.diff(x, 1) duy = ue.diff(y, 1) fe = ue.diff(x, 2) + ue.diff(y, 2) + ue.diff(z, 2) N = (24, 24, 24) K0 = FunctionSpace(N[0], 'Fourier', dtype='d') K1 = FunctionSpace(N[1], 'Fourier', dtype='D') SD = FunctionSpace(N[2], 'Legendre', bc=(0, 0)) ST = FunctionSpace(N[2], 'Legendre') TD = TensorProductSpace(comm, (K0, K1, SD), axes=(2, 1, 0)) TT = TensorProductSpace(comm, (K0, K1, ST), axes=(2, 1, 0))
def test_issue_5284(): A, B = symbols('A B', commutative=False) assert (x * A).subs(x**2 * A, B) == x * A assert (A**2).subs(A**3, B) == A**2 assert (A**6).subs(A**3, B) == B**2
Answer does not match text. """ from __future__ import division from sympy import Dummy from sympy import expand, symbols from sympy.physics.mechanics import ReferenceFrame, Point from sympy.physics.mechanics import dynamicsymbols from util import msprint, partial_velocities from util import generalized_active_forces, potential_energy q1, q2, q3, q4, q5, q6 = q = dynamicsymbols('q1:7') u1, u2, u3, u4, u5, u6 = u = dynamicsymbols('u1:7') # L' is the natural length of the springs a, k, L_prime = symbols('a k L\'', real=True, positive=True) # reference frames X = ReferenceFrame('X') C = X.orientnew('C', 'body', [q4, q5, q6], 'xyz') # define points pO = Point('O') # point O is fixed in X pC_star = pO.locatenew('C*', a*(q1*X.x + q2*X.y + q3*X.z)) # define points of the cube connected to springs pC1 = pC_star.locatenew('C1', a*(C.x + C.y - C.z)) pC2 = pC_star.locatenew('C2', a*(C.y + C.z - C.x)) pC3 = pC_star.locatenew('C3', a*(C.z + C.x - C.y)) # define fixed spring points pk1 = pO.locatenew('k1', L_prime * X.x + a*(X.x + X.y - X.z)) pk2 = pO.locatenew('k2', L_prime * X.y + a*(X.y + X.z - X.x))
from sympy import symbols, diff x, y, t = symbols('x y t', real=True) f = t*x - y result = diff(f,t) print(result) # t f2 = t + x - y result2 = diff(f2,t) print(result2) # x
def SpinWeight_minus2_SphHarmonics(maximum_l=8, filename=os.path.join( "SpinWeight_minus2_SphHarmonics", "SpinWeight_minus2_SphHarmonics.h")): # Step 2: Defining the Goldberg function # Step 2.a: Declare SymPy symbols: th, ph = sp.symbols('th ph', real=True) m = sp.symbols('m', integer=True) # Step 2.b: Define the Goldberg formula for spin-weighted spherical harmonics # (https://aip.scitation.org/doi/10.1063/1.1705135); # referenced & described in Wikipedia Spin-weighted spherical harmonics article: # https://en.wikipedia.org/w/index.php?title=Spin-weighted_spherical_harmonics&oldid=853425244 def Y(s, l, m, th, ph, GenerateMathematicaCode=False): Sum = 0 for r in range(l - s + 1): if GenerateMathematicaCode == True: # Mathematica needs expression to be in terms of cotangent, so that code validation below # yields identity with existing Mathematica notebook on spin-weighted spherical harmonics. Sum += sp.binomial(l - s, r) * sp.binomial( l + s, r + s - m) * (-1)**(l - r - s) * sp.exp( sp.I * m * ph) * sp.cot(th / 2)**(2 * r + s - m) else: # SymPy C code generation cannot handle the cotangent function, so define cot(th/2) as 1/tan(th/2): Sum += sp.binomial(l - s, r) * sp.binomial( l + s, r + s - m) * (-1)**(l - r - s) * sp.exp( sp.I * m * ph) / sp.tan(th / 2)**(2 * r + s - m) return (-1)**m * sp.simplify( sp.sqrt( sp.factorial(l + m) * sp.factorial(l - m) * (2 * l + 1) / (4 * sp.pi * sp.factorial(l + s) * sp.factorial(l - s))) * sp.sin(th / 2)**(2 * l) * Sum) # Step 3: (DISABLED FOR NOW; PASSES TEST). # Code Validation against Mathematica notebook: # https://demonstrations.wolfram.com/versions/source.jsp?id=SpinWeightedSphericalHarmonics&version=0012 # # For the l=0 case m=0, otherwise there is a divide-by-zero in the Y() function above. # print("FullSimplify[Y[-2, 0, 0, th, ph]-"+str(sp.mathematica_code(sp.simplify(Y(-2, 0, 0, th, ph,GenerateMathematicaCode=True))))+"] \n") # Agrees with Mathematica notebook for l = 0 # # Check the other cases # for l in range(1,9): # Agrees with Mathematica notebook for l = 1, 2, 4, 5, 6, 7, 8; # print("FullSimplify[Y[-2, "+str(l)+", m, th, ph]-("+ # str(sp.mathematica_code(sp.simplify(Y(-2, l, m, th, ph, GenerateMathematicaCode=True)))).replace("binomial","Binomial").replace("factorial","Factorial")+")] \n") # Step 4: Generating C Code function for computing # s=-2 spin-weighted spherical harmonics, # using NRPy+'s outputC() function. outCparams = "preindent=3,outCfileaccess=a,outCverbose=False,includebraces=True" with open(filename, "w") as file: file.write(""" void SpinWeight_minus2_SphHarmonics(const int l, const int m, const REAL th, const REAL ph, REAL *reYlmswm2_l_m, REAL *imYlmswm2_l_m) { if(l<0 || l>""" + str(maximum_l) + """ || m<-l || m>+l) { printf("ERROR: SpinWeight_minus2_SphHarmonics handles only l=[0,""" + str(maximum_l) + """] and only m=[-l,+l] is defined.\\n"); printf(" You chose l=%d and m=%d, which is out of these bounds.\\n",l,m); exit(1); }\n""") file.write("switch(l) {\n") for l in range(maximum_l + 1): # Output values up to and including l=8. file.write(" case " + str(l) + ":\n") file.write(" switch(m) {\n") for m in range(-l, l + 1): file.write(" case " + str(m) + ":\n") Y_m2_lm = Y(-2, l, m, th, ph) Cstring = outputC( [sp.re(Y_m2_lm), sp.im(Y_m2_lm)], ["*reYlmswm2_l_m", "*imYlmswm2_l_m"], "returnstring", outCparams) file.write(Cstring) file.write(" return;\n") file.write(" } /* End switch(m) */\n") file.write(" } /* End switch(l) */\n") file.write("} /* End function SpinWeight_minus2_SphHarmonics() */\n")
def eval_function(f, x0): f = sympify_expr(f) x = symbols("x") return str(f.evalf(subs={x: x0}))
def test_get_subNO(): p, q, r = symbols('p,q,r') assert NO(F(p) * F(q) * F(r)).get_subNO(1) == NO(F(p) * F(r)) assert NO(F(p) * F(q) * F(r)).get_subNO(0) == NO(F(q) * F(r)) assert NO(F(p) * F(q) * F(r)).get_subNO(2) == NO(F(p) * F(q))
def test_to_equation(self): self.assertEqual( pybamm.Symbol("test").to_equation(), sympy.symbols("test"))
def test_substitute_dummies_new_indices(): i, j = symbols('i j', below_fermi=True, cls=Dummy) a, b = symbols('a b', above_fermi=True, cls=Dummy) p, q = symbols('p q', cls=Dummy) f = Function('f') assert substitute_dummies(f(i, a, p) - f(j, b, q), new_indices=True) == 0
BE = A_e.series(p, 0, 4) - A.subs(theta, 1).series(p, 0, 4) CN = A_e.series(p, 0, 4) - A.subs(theta, half).series(p, 0, 4) FE BE CN # Ratio of amplification factors FE = 1 - (A.subs(theta, 0)/A_e).series(p, 0, 4) BE = 1 - (A.subs(theta, 1)/A_e).series(p, 0, 4) CN = 1 - (A.subs(theta, half)/A_e).series(p, 0, 4) FE BE CN print "Error in solution:" n, a, dt, t, T = sym.symbols('n a dt t T') u_e = sym.exp(-p*n) u_n = A**n error = u_e.series(p, 0, 4) - u_n.subs(theta, 0).series(p, 0, 4) print error FE = error error = error.subs('n', 't/dt').subs(p, 'a*dt') #error = error.extract_leading_order(dt)[0][0] # as_leading_term is simpler error = error.as_leading_term(dt) print 'Global error at a point t:', error # error = error.removeO() # get rid of the O() term error_L2 = sym.sqrt(sym.integrate(error**2, (t, 0, T))) print 'L2 error:', sym.simplify(error_L2) #error_error_L2 = error_L2.series(dt, 0, 3).as_leading_term(dt) # series breaks down
def test_substitute_dummies_without_dummies(): i, j = symbols('i,j') assert substitute_dummies(att(i, j) + 2) == att(i, j) + 2 assert substitute_dummies(att(i, j) + 1) == att(i, j) + 1
def test_substitute_dummies_substitution_order(): i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy) f = Function('f') from sympy.utilities.iterables import variations for permut in variations([i, j, k, l], 4): assert substitute_dummies(f(*permut) - f(i, j, k, l)) == 0
def test_complex_apply(): n, m = symbols("n,m") o = Bd(0) * B(0) * Bd(1) * B(0) e = apply_operators(o * BKet([n, m])) answer = sqrt(n) * sqrt(m + 1) * (-1 + n) * BKet([-1 + n, 1 + m]) assert expand(e) == expand(answer)
def test_substitute_dummies_SQ_operator(): i, j = symbols('i j', cls=Dummy) assert substitute_dummies( att(i, j) * Fd(i) * F(j) - att(j, i) * Fd(j) * F(i)) == 0
import numpy as np from numpy import exp from numpy import pi from numpy import sqrt from numpy import log import numpy.testing as nut import scipy.integrate as si import mpmath as mp import sympy as sp import matplotlib.pylab as plt # This file is only there to be able to see the source functions IXXP and IYYP once the propagation is over x, xp, y, yp, dl = sp.symbols('x xp y yp dl') #DEFINITION OF MATHEMATICAL OBJECTS #Definition of the transformation matrices def matrixFlightSymbolic(L): # For a flight path of length return np.array([[1, -L, 0], [0, 1, 0], [0, 0, 1]]) def matrixMonoPlaneSymbolic( b, ThetaB): # For a perfect flat crystal monochromator return np.array([[b, 0, 0], [0, 1 / b, (1 - 1 / b) * np.tan(ThetaB)], [0, 0, 1]]) def matrixMonoBentSymbolic( b, Fc, ThetaB
def test_number_operator(): n = symbols("n") o = Bd(0) * B(0) e = apply_operators(o * BKet([n])) assert e == n * BKet([n])
xAxis = list(range(-128,129)) yAxis = list(range(-128,129)) # In[ ]: #constants maxSpeed = 100 #dic to store data dic = {} noPositive = 0 # In[24]: Fc = sympy.symbols("Fc", real=True) eq = sympy.Eq((Fc)**2, maxSpeed**2) sol=sympy.solve(eq) print(sol) # In[77]: Fa, Fb = sympy.symbols("Fa Fb", real=True) Fx = 0 Fy = 128 eq1 = sympy.Eq((Fy-sqrt(3)*Fx)*Fb-(Fy+sqrt(3)*Fx)*Fa, 0) eq2 = sympy.Eq(((sqrt(3)/2)*Fb+(sqrt(3)/2)*Fa)**2+(0.5*Fb-0.5*Fa)**2, 10000) sol=sympy.solve([eq1, eq2]) if sol[0][Fa] >0 and sol[0][Fb]>0: print("yes")
def test_basic_apply(): n = symbols("n") e = B(0) * BKet([n]) assert apply_operators(e) == sqrt(n) * BKet([n - 1]) e = Bd(0) * BKet([n]) assert apply_operators(e) == sqrt(n + 1) * BKet([n + 1])
def test_big_expr(): f = Function('f') x = symbols('x') e1 = Dagger( AntiCommutator( Operator('A') + Operator('B'), Pow(DifferentialOperator(Derivative(f(x), x), f(x)), 3)) * TensorProduct(Jz**2, Operator('A') + Operator('B'))) * (JzBra(1, 0) + JzBra( 1, 1)) * (JzKet(0, 0) + JzKet(1, -1)) e2 = Commutator(Jz**2, Operator('A') + Operator('B')) * AntiCommutator( Dagger(Operator('C') * Operator('D')), Operator('E').inv()**2) * Dagger(Commutator(Jz, J2)) e3 = Wigner3j(1, 2, 3, 4, 5, 6) * TensorProduct( Commutator( Operator('A') + Dagger(Operator('B')), Operator('C') + Operator('D')), Jz - J2) * Dagger( OuterProduct(Dagger(JzBra(1, 1)), JzBra( 1, 0))) * TensorProduct( JzKetCoupled(1, 1, (1, 1)) + JzKetCoupled(1, 0, (1, 1)), JzKetCoupled(1, -1, (1, 1))) e4 = (ComplexSpace(1) * ComplexSpace(2) + FockSpace()**2) * (L2(Interval(0, oo)) + HilbertSpace()) assert str( e1 ) == '(Jz**2)x(Dagger(A) + Dagger(B))*{Dagger(DifferentialOperator(Derivative(f(x), x),f(x)))**3,Dagger(A) + Dagger(B)}*(<1,0| + <1,1|)*(|0,0> + |1,-1>)' ascii_str = \ """\ / 3 \\ \n\ |/ +\\ | \n\ 2 / + +\\ <| /d \\ | + +> \n\ /J \\ x \\A + B /*||DifferentialOperator|--(f(x)),f(x)| | ,A + B |*(<1,0| + <1,1|)*(|0,0> + |1,-1>)\n\ \\ z/ \\\\ \\dx / / / \ """ ucode_str = \ u("""\ ⎧ 3 ⎫ \n\ ⎪⎛ †⎞ ⎪ \n\ 2 ⎛ † †⎞ ⎨⎜ ⎛d ⎞ ⎟ † †⎬ \n\ ⎛J ⎞ ⨂ ⎝A + B ⎠⋅⎪⎜DifferentialOperator⎜──(f(x)),f(x)⎟ ⎟ ,A + B ⎪⋅(⟨1,0❘ + ⟨1,1❘)⋅(❘0,0⟩ + ❘1,-1⟩)\n\ ⎝ z⎠ ⎩⎝ ⎝dx ⎠ ⎠ ⎭ \ """) assert pretty(e1) == ascii_str assert upretty(e1) == ucode_str assert latex(e1) == \ r'{J_z^{2}}\otimes \left({A^{\dagger} + B^{\dagger}}\right) \left\{\left(DifferentialOperator\left(\frac{d}{d x} f{\left (x \right )},f{\left (x \right )}\right)^{\dagger}\right)^{3},A^{\dagger} + B^{\dagger}\right\} \left({\left\langle 1,0\right|} + {\left\langle 1,1\right|}\right) \left({\left|0,0\right\rangle } + {\left|1,-1\right\rangle }\right)' sT( e1, "Mul(TensorProduct(Pow(JzOp(Symbol('J')), Integer(2)), Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), AntiCommutator(Pow(Dagger(DifferentialOperator(Derivative(Function('f')(Symbol('x')), Tuple(Symbol('x'), Integer(1))),Function('f')(Symbol('x')))), Integer(3)),Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), Add(JzBra(Integer(1),Integer(0)), JzBra(Integer(1),Integer(1))), Add(JzKet(Integer(0),Integer(0)), JzKet(Integer(1),Integer(-1))))" ) assert str(e2) == '[Jz**2,A + B]*{E**(-2),Dagger(D)*Dagger(C)}*[J2,Jz]' ascii_str = \ """\ [ 2 ] / -2 + +\\ [ 2 ]\n\ [/J \\ ,A + B]*<E ,D *C >*[J ,J ]\n\ [\\ z/ ] \\ / [ z]\ """ ucode_str = \ u("""\ ⎡ 2 ⎤ ⎧ -2 † †⎫ ⎡ 2 ⎤\n\ ⎢⎛J ⎞ ,A + B⎥⋅⎨E ,D ⋅C ⎬⋅⎢J ,J ⎥\n\ ⎣⎝ z⎠ ⎦ ⎩ ⎭ ⎣ z⎦\ """) assert pretty(e2) == ascii_str assert upretty(e2) == ucode_str assert latex(e2) == \ r'\left[J_z^{2},A + B\right] \left\{E^{-2},D^{\dagger} C^{\dagger}\right\} \left[J^2,J_z\right]' sT( e2, "Mul(Commutator(Pow(JzOp(Symbol('J')), Integer(2)),Add(Operator(Symbol('A')), Operator(Symbol('B')))), AntiCommutator(Pow(Operator(Symbol('E')), Integer(-2)),Mul(Dagger(Operator(Symbol('D'))), Dagger(Operator(Symbol('C'))))), Commutator(J2Op(Symbol('J')),JzOp(Symbol('J'))))" ) assert str(e3) == \ "Wigner3j(1, 2, 3, 4, 5, 6)*[Dagger(B) + A,C + D]x(-J2 + Jz)*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x|1,-1,j1=1,j2=1>" ascii_str = \ """\ [ + ] / 2 \\ \n\ /1 3 5\\*[B + A,C + D]x |- J + J |*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x |1,-1,j1=1,j2=1>\n\ | | \\ z/ \n\ \\2 4 6/ \ """ ucode_str = \ u("""\ ⎡ † ⎤ ⎛ 2 ⎞ \n\ ⎛1 3 5⎞⋅⎣B + A,C + D⎦⨂ ⎜- J + J ⎟⋅❘1,0⟩⟨1,1❘⋅(❘1,0,j₁=1,j₂=1⟩ + ❘1,1,j₁=1,j₂=1⟩)⨂ ❘1,-1,j₁=1,j₂=1⟩\n\ ⎜ ⎟ ⎝ z⎠ \n\ ⎝2 4 6⎠ \ """) assert pretty(e3) == ascii_str assert upretty(e3) == ucode_str assert latex(e3) == \ r'\left(\begin{array}{ccc} 1 & 3 & 5 \\ 2 & 4 & 6 \end{array}\right) {\left[B^{\dagger} + A,C + D\right]}\otimes \left({- J^2 + J_z}\right) {\left|1,0\right\rangle }{\left\langle 1,1\right|} \left({{\left|1,0,j_{1}=1,j_{2}=1\right\rangle } + {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }}\right)\otimes {{\left|1,-1,j_{1}=1,j_{2}=1\right\rangle }}' sT( e3, "Mul(Wigner3j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)), TensorProduct(Commutator(Add(Dagger(Operator(Symbol('B'))), Operator(Symbol('A'))),Add(Operator(Symbol('C')), Operator(Symbol('D')))), Add(Mul(Integer(-1), J2Op(Symbol('J'))), JzOp(Symbol('J')))), OuterProduct(JzKet(Integer(1),Integer(0)),JzBra(Integer(1),Integer(1))), TensorProduct(Add(JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))), JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))), JzKetCoupled(Integer(1),Integer(-1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))))" ) assert str(e4) == '(C(1)*C(2)+F**2)*(L2(Interval(0, oo))+H)' ascii_str = \ """\ // 1 2\\ x2\\ / 2 \\\n\ \\\\C x C / + F / x \\L + H/\ """ ucode_str = \ u("""\ ⎛⎛ 1 2⎞ ⨂2⎞ ⎛ 2 ⎞\n\ ⎝⎝C ⨂ C ⎠ ⊕ F ⎠ ⨂ ⎝L ⊕ H⎠\ """) assert pretty(e4) == ascii_str assert upretty(e4) == ucode_str assert latex(e4) == \ r'\left(\left(\mathcal{C}^{1}\otimes \mathcal{C}^{2}\right)\oplus {\mathcal{F}}^{\otimes 2}\right)\otimes \left({\mathcal{L}^2}\left( \left[0, \infty\right) \right)\oplus \mathcal{H}\right)' sT( e4, "TensorProductHilbertSpace((DirectSumHilbertSpace(TensorProductHilbertSpace(ComplexSpace(Integer(1)),ComplexSpace(Integer(2))),TensorPowerHilbertSpace(FockSpace(),Integer(2)))),(DirectSumHilbertSpace(L2(Interval(Integer(0), oo, false, true)),HilbertSpace())))" )
#instalar matplotlib y seaborn import sympy as syp from sympy.plotting import plot import seaborn as sns sns.set() sns.set_style("whitegrid", {'grid.linestyle': '--'}) x = syp.symbols('x') p1 = syp.plot((x+7)*(x-5) , show=False) p2 = syp.plot((x-5)**3, show=False) #p2.xlim=-40,40 p1.append(p2[0]) p1.xlim=-40,40 p1.ylim=-40,40 p1.title='Hola' #p1.autoscale=True #p1.show() p1.save('/home/yan/graph.svg')
def test_state(): x = symbols('x') bra = Bra() ket = Ket() bra_tall = Bra(x / 2) ket_tall = Ket(x / 2) tbra = TimeDepBra() tket = TimeDepKet() assert str(bra) == '<psi|' assert pretty(bra) == '<psi|' assert upretty(bra) == u'⟨ψ❘' assert latex(bra) == r'{\left\langle \psi\right|}' sT(bra, "Bra(Symbol('psi'))") assert str(ket) == '|psi>' assert pretty(ket) == '|psi>' assert upretty(ket) == u'❘ψ⟩' assert latex(ket) == r'{\left|\psi\right\rangle }' sT(ket, "Ket(Symbol('psi'))") assert str(bra_tall) == '<x/2|' ascii_str = \ """\ / |\n\ / x|\n\ \\ -|\n\ \\2|\ """ ucode_str = \ u("""\ ╱ │\n\ ╱ x│\n\ ╲ ─│\n\ ╲2│\ """) assert pretty(bra_tall) == ascii_str assert upretty(bra_tall) == ucode_str assert latex(bra_tall) == r'{\left\langle \frac{x}{2}\right|}' sT(bra_tall, "Bra(Mul(Rational(1, 2), Symbol('x')))") assert str(ket_tall) == '|x/2>' ascii_str = \ """\ | \\ \n\ |x \\\n\ |- /\n\ |2/ \ """ ucode_str = \ u("""\ │ ╲ \n\ │x ╲\n\ │─ ╱\n\ │2╱ \ """) assert pretty(ket_tall) == ascii_str assert upretty(ket_tall) == ucode_str assert latex(ket_tall) == r'{\left|\frac{x}{2}\right\rangle }' sT(ket_tall, "Ket(Mul(Rational(1, 2), Symbol('x')))") assert str(tbra) == '<psi;t|' assert pretty(tbra) == u'<psi;t|' assert upretty(tbra) == u'⟨ψ;t❘' assert latex(tbra) == r'{\left\langle \psi;t\right|}' sT(tbra, "TimeDepBra(Symbol('psi'),Symbol('t'))") assert str(tket) == '|psi;t>' assert pretty(tket) == '|psi;t>' assert upretty(tket) == u'❘ψ;t⟩' assert latex(tket) == r'{\left|\psi;t\right\rangle }' sT(tket, "TimeDepKet(Symbol('psi'),Symbol('t'))")
import importlib from sympy import symbols, sin import numpy as np from shenfun import inner, div, grad, TestFunction, TrialFunction, Basis, \ Array, Function try: import matplotlib.pyplot as plt except ImportError: plt = None # Collect basis from either Chebyshev or Legendre submodules family = sys.argv[-1].lower() if len(sys.argv) == 2 else 'chebyshev' shen = importlib.import_module('.'.join(('shenfun', family))) # Use sympy to compute a rhs, given an analytical solution x = symbols("x") ue = sin(np.pi*x)*(1-x**2) fe = ue.diff(x, 2) # Size of discretization N = 32 SD = Basis(N, family=family, bc='Neumann') X = SD.mesh() u = TrialFunction(SD) v = TestFunction(SD) # Get f on quad points fj = Array(SD, buffer=fe) # Compute right hand side of Poisson equation