def test_issue_15539(): assert series(atan(x), x, -oo) == ( -1 / (5 * x ** 5) + 1 / (3 * x ** 3) - 1 / x - pi / 2 + O(x ** (-6), (x, -oo)) ) assert series(atan(x), x, oo) == ( -1 / (5 * x ** 5) + 1 / (3 * x ** 3) - 1 / x + pi / 2 + O(x ** (-6), (x, oo)) )
def inv_ε_expan(η_iter, z, h, N): ηiη0 = 0 for q, η in enumerate(η_iter): ηiη0 += η * (z * h) ** q / (η_iter[0] * sy.factorial(q)) εiε0 = sy.series(ηiη0 ** 2, x=h, n=N) ε0iε = sy.series(1 / εiε0, x=h, n=N) return (-ε0iε / η_iter[0] ** 2).expand().removeO()
def Problem2(): t, x = symbols('t x') f = exp(t) expr = series(f, t, 0, 5) expr = expr.removeO() print('') print('Taylor expansion of f(t) = exp(t) around t=0') print(expr) func = sin(x) N = 100 for i in range(2, 7): expr = series(func, x, 0, i * 2) expr = expr.removeO() taylorEval = lambdify(x, expr, 'numpy') x = np.linspace(0, 2 * np.pi, N) plt.plot(x, taylorEval(x)) x = symbols('x') plt.ylim([-2.0, 2.0]) plt.xlim([0.0, 2 * np.pi]) x = np.linspace(0, 2 * np.pi, N) plt.plot(x, np.sin(x)) plt.legend([ 'series, N = 4', 'series, N = 6', 'series, N = 8', 'series, N = 10', 'series, N = 12', 'series, N = 14' ]) plt.show()
def test_issue_7259(): assert series( LambertW(x), x ) == x - x ** 2 + 3 * x ** 3 / 2 - 8 * x ** 4 / 3 + 125 * x ** 5 / 24 + O(x ** 6) assert series(LambertW(x ** 2), x, n=8) == x ** 2 - x ** 4 + 3 * x ** 6 / 2 + O( x ** 8 ) assert series(LambertW(sin(x)), x, n=4) == x - x ** 2 + 4 * x ** 3 / 3 + O(x ** 4)
def test_sec(): x = symbols('x', real=True) z = symbols('z') assert sec.nargs == FiniteSet(1) assert sec(0) == 1 assert sec(pi) == -1 assert sec(pi / 2) == zoo assert sec(-pi / 2) == zoo assert sec(pi / 6) == 2 * sqrt(3) / 3 assert sec(pi / 3) == 2 assert sec(5 * pi / 2) == zoo assert sec(9 * pi / 7) == -sec(2 * pi / 7) assert sec(I) == 1 / cosh(1) assert sec(x * I) == 1 / cosh(x) assert sec(-x) == sec(x) assert sec(x).rewrite(exp) == 1 / (exp(I * x) / 2 + exp(-I * x) / 2) assert sec(x).rewrite(sin) == sec(x) assert sec(x).rewrite(cos) == 1 / cos(x) assert sec(x).rewrite(tan) == (tan(x / 2)**2 + 1) / (-tan(x / 2)**2 + 1) assert sec(x).rewrite(pow) == sec(x) assert sec(x).rewrite(sqrt) == sec(x) assert sec(z).conjugate() == sec(conjugate(z)) assert (sec(z).as_real_imag() == ( cos(re(z)) * cosh(im(z)) / (sin(re(z))**2 * sinh(im(z))**2 + cos(re(z))**2 * cosh(im(z))**2), sin(re(z)) * sinh(im(z)) / (sin(re(z))**2 * sinh(im(z))**2 + cos(re(z))**2 * cosh(im(z))**2))) assert sec(x).expand(trig=True) == 1 / cos(x) assert sec(2 * x).expand(trig=True) == 1 / (2 * cos(x)**2 - 1) assert sec(x).is_real == True assert sec(z).is_real == None assert sec(x).as_leading_term() == sec(x) assert sec(0).is_bounded == True assert sec(x).is_bounded == None assert sec(pi / 2).is_bounded == False assert series(sec(x), x, x0=0, n=6) == 1 + x**2 / 2 + 5 * x**4 / 24 + O(x**6) # https://github.com/sympy/sympy/issues/7166 assert series(sqrt(sec(x))) == 1 + x**2 / 4 + 7 * x**4 / 96 + O(x**6) assert sec(x).diff(x) == tan(x) * sec(x) # Taylor Term checks assert sec(z).taylor_term(4, z) == 5 * z**4 / 24 assert sec(z).taylor_term(6, z) == 61 * z**6 / 720 assert sec(z).taylor_term(5, z) == 0
def test_csc(): x = symbols('x', real=True) z = symbols('z') # https://github.com/sympy/sympy/issues/6707 cosecant = csc('x') alternate = 1/sin('x') assert cosecant.equals(alternate) == True assert alternate.equals(cosecant) == True assert csc.nargs == FiniteSet(1) assert csc(0) == zoo assert csc(pi) == zoo assert csc(pi/2) == 1 assert csc(-pi/2) == -1 assert csc(pi/6) == 2 assert csc(pi/3) == 2*sqrt(3)/3 assert csc(5*pi/2) == 1 assert csc(9*pi/7) == -csc(2*pi/7) assert csc(I) == -I/sinh(1) assert csc(x*I) == -I/sinh(x) assert csc(-x) == -csc(x) assert csc(x).rewrite(exp) == 2*I/(exp(I*x) - exp(-I*x)) assert csc(x).rewrite(sin) == 1/sin(x) assert csc(x).rewrite(cos) == csc(x) assert csc(x).rewrite(tan) == (tan(x/2)**2 + 1)/(2*tan(x/2)) assert csc(z).conjugate() == csc(conjugate(z)) assert (csc(z).as_real_imag() == (sin(re(z))*cosh(im(z))/(sin(re(z))**2*cosh(im(z))**2 + cos(re(z))**2*sinh(im(z))**2), -cos(re(z))*sinh(im(z))/(sin(re(z))**2*cosh(im(z))**2 + cos(re(z))**2*sinh(im(z))**2))) assert csc(x).expand(trig=True) == 1/sin(x) assert csc(2*x).expand(trig=True) == 1/(2*sin(x)*cos(x)) assert csc(x).is_real == True assert csc(z).is_real == None assert csc(x).as_leading_term() == csc(x) assert csc(0).is_bounded == False assert csc(x).is_bounded == None assert csc(pi/2).is_bounded == True assert series(csc(x), x, x0=pi/2, n=6) == \ 1 + (x - pi/2)**2/2 + 5*(x - pi/2)**4/24 + O((x - pi/2)**6, (x, pi/2)) assert series(csc(x), x, x0=0, n=6) == \ 1/x + x/6 + 7*x**3/360 + 31*x**5/15120 + O(x**6) assert csc(x).diff(x) == -cot(x)*csc(x)
def test_sec(): x = symbols('x', real=True) z = symbols('z') assert sec.nargs == FiniteSet(1) assert sec(0) == 1 assert sec(pi) == -1 assert sec(pi/2) == zoo assert sec(-pi/2) == zoo assert sec(pi/6) == 2*sqrt(3)/3 assert sec(pi/3) == 2 assert sec(5*pi/2) == zoo assert sec(9*pi/7) == -sec(2*pi/7) assert sec(I) == 1/cosh(1) assert sec(x*I) == 1/cosh(x) assert sec(-x) == sec(x) assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2) assert sec(x).rewrite(sin) == sec(x) assert sec(x).rewrite(cos) == 1/cos(x) assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1) assert sec(x).rewrite(pow) == sec(x) assert sec(x).rewrite(sqrt) == sec(x) assert sec(z).conjugate() == sec(conjugate(z)) assert (sec(z).as_real_imag() == (cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 + cos(re(z))**2*cosh(im(z))**2), sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 + cos(re(z))**2*cosh(im(z))**2))) assert sec(x).expand(trig=True) == 1/cos(x) assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1) assert sec(x).is_real == True assert sec(z).is_real == None assert sec(x).as_leading_term() == sec(x) assert sec(0).is_bounded == True assert sec(x).is_bounded == None assert sec(pi/2).is_bounded == False assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6) # https://github.com/sympy/sympy/issues/7166 assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6) assert sec(x).diff(x) == tan(x)*sec(x) # Taylor Term checks assert sec(z).taylor_term(4, z) == 5*z**4/24 assert sec(z).taylor_term(6, z) == 61*z**6/720 assert sec(z).taylor_term(5, z) == 0
def exercise_6_43(): z = sp.Symbol('z') b_of_z = 1/(1 - z) sp.pprint('\n' + 'b_of_z:') sp.pprint(b_of_z) e_b_prime_of_z = z**2/(1 - z)**2 sp.pprint('\n' +'e_b_prime_of_z:') sp.pprint(e_b_prime_of_z) e_b_prime_of_n = sp.series(e_b_prime_of_z, z, 0, 10) sp.pprint('\n' +'e_b_prime_of_n:') sp.pprint(e_b_prime_of_n) e_b_of_z = sp.integrate(e_b_prime_of_z, z) constant = e_b_of_z.subs(z, 0) e_b_of_z = e_b_of_z - constant sp.pprint('\n' +'e_b_of_z:') sp.pprint(e_b_of_z) e_b_of_n = sp.series(e_b_of_z, z, 0, 10) sp.pprint('\n' +'e_b_of_n:') sp.pprint(e_b_of_n) e_b_prime_of_z = sp.diff(e_b_of_z, z) sp.pprint('\n' +'e_b_prime_of_z:') sp.pprint(e_b_prime_of_z) f_of_z = sp.together((1 - z)**2*e_b_prime_of_z) sp.pprint('\n' +'f_of_z:') sp.pprint(f_of_z) F_of_z = sp.integrate(f_of_z, z) sp.pprint('\n' +'F_of_z:') sp.pprint(F_of_z) c_b_of_z = (e_b_of_z.subs(z, 0) + F_of_z)/(1 - z)**2 sp.pprint('\n' +'c_b_of_z:') sp.pprint(c_b_of_z) c_b_of_n = sp.series(c_b_of_z, z, 0, 10) sp.pprint('\n' +'c_b_of_n:') sp.pprint(c_b_of_n)
def test_sec(): x = symbols('x', real=True) z = symbols('z') assert sec.nargs == 1 assert sec(0) == 1 assert sec(pi) == -1 assert sec(pi/2) == oo assert sec(-pi/2) == oo assert sec(pi/6) == 2*sqrt(3)/3 assert sec(pi/3) == 2 assert sec(5*pi/2) == oo assert sec(9*pi/7) == -sec(2*pi/7) assert sec(I) == 1/cosh(1) assert sec(x*I) == 1/cosh(x) assert sec(-x) == sec(x) assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2) assert sec(x).rewrite(sin) == sec(x) assert sec(x).rewrite(cos) == 1/cos(x) assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1) assert sec(x).rewrite(pow) == sec(x) assert sec(x).rewrite(sqrt) == sec(x) assert sec(z).conjugate() == sec(conjugate(z)) assert (sec(z).as_real_imag() == (cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 + cos(re(z))**2*cosh(im(z))**2), sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 + cos(re(z))**2*cosh(im(z))**2))) assert sec(x).expand(trig=True) == 1/cos(x) assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1) assert sec(x).is_real == True assert sec(z).is_real == None assert sec(x).as_leading_term() == sec(x) assert sec(0).is_bounded == True assert sec(x).is_bounded == None assert sec(pi/2).is_bounded == False assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6) # https://code.google.com/p/sympy/issues/detail?id=4067 assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6) # https://code.google.com/p/sympy/issues/detail?id=4068 assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) == 1/sqrt(x) +x**(S(3)/2)/12 + x**(S(7)/2)/160 + O(x**4)) assert sec(x).diff(x) == tan(x)*sec(x)
def test_2124(): assert series(1, x) == 1 assert S(0).lseries(x).next() == 0 assert cos(x).series() == cos(x).series(x) raises(ValueError, lambda: cos(x + y).series()) raises(ValueError, lambda: x.series(dir="")) assert (cos(x).series(x, 1).removeO().subs(x, x - 1) - cos(x + 1).series(x).removeO().subs(x, x - 1)).expand() == 0 e = cos(x).series(x, 1, n=None) assert [e.next() for i in range(2)] == [cos(1), -((x - 1) * sin(1))] e = cos(x).series(x, 1, n=None, dir='-') assert [e.next() for i in range(2)] == [cos(1), (1 - x) * sin(1)] # the following test is exact so no need for x -> x - 1 replacement assert abs(x).series(x, 1, dir='-') == x assert exp(x).series(x, 1, dir='-', n=3).removeO().subs(x, x - 1) == \ E + E*(x - 1) + E*(x - 1)**2/2 D = Derivative assert D(x**2 + x**3 * y**2, x, 2, y, 1).series(x).doit() == 12 * x * y assert D(cos(x), x).lseries().next() == D(1, x) assert D(exp(x), x).series(n=3) == D(1, x) + D(x, x) + D(x**2 / 2, x) + O(x**3) assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4 * x assert (1 + x + O(x**2)).getn() == 2 assert (1 + x).getn() is None assert ((1 / sin(x))**oo).series() == oo logx = Symbol('logx') assert ((sin(x))**y).nseries(x, n=1, logx=logx) == \ exp(y*logx) + O(x*exp(y*logx), x) raises(NotImplementedError, lambda: series(Function("f")(x))) assert sin(1 / x).series(x, oo, n=5) == 1 / x - 1 / (6 * x**3) assert abs(x).series(x, oo, n=5, dir='+') == x assert abs(x).series(x, -oo, n=5, dir='-') == -x assert abs(-x).series(x, oo, n=5, dir='+') == x assert abs(-x).series(x, -oo, n=5, dir='-') == -x assert exp(x*log(x)).series(n=3) == \ 1 + x*log(x) + x**2*log(x)**2/2 + O(x**3*log(x)**3) # XXX is this right? If not, fix "ngot > n" handling in expr. p = Symbol('p', positive=True) assert exp(sqrt(p)**3*log(p)).series(n=3) == \ 1 + p**S('3/2')*log(p) + O(p**3*log(p)**3) assert exp(sin(x) * log(x)).series(n=2) == 1 + x * log(x) + O(x**2 * log(x)**2)
def test_2124(): assert series(1, x) == 1 assert S(0).lseries(x).next() == 0 assert cos(x).series() == cos(x).series(x) raises(ValueError, lambda: cos(x + y).series()) raises(ValueError, lambda: x.series(dir="")) assert (cos(x).series(x, 1).removeO().subs(x, x - 1) - cos(x + 1).series(x).removeO().subs(x, x - 1)).expand() == 0 e = cos(x).series(x, 1, n=None) assert [e.next() for i in range(2)] == [cos(1), -((x - 1)*sin(1))] e = cos(x).series(x, 1, n=None, dir='-') assert [e.next() for i in range(2)] == [cos(1), (1 - x)*sin(1)] # the following test is exact so no need for x -> x - 1 replacement assert abs(x).series(x, 1, dir='-') == x assert exp(x).series(x, 1, dir='-', n=3).removeO().subs(x, x - 1) == \ E + E*(x - 1) + E*(x - 1)**2/2 D = Derivative assert D(x**2 + x**3*y**2, x, 2, y, 1).series(x).doit() == 12*x*y assert D(cos(x), x).lseries().next() == D(1, x) assert D( exp(x), x).series(n=3) == D(1, x) + D(x, x) + D(x**2/2, x) + O(x**3) assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4*x assert (1 + x + O(x**2)).getn() == 2 assert (1 + x).getn() is None assert ((1/sin(x))**oo).series() == oo logx = Symbol('logx') assert ((sin(x))**y).nseries(x, n=1, logx=logx) \ == exp(y*logx) + O(x*exp(y*logx), x) raises(NotImplementedError, lambda: series(Function("f")(x))) assert sin(1/x).series(x, oo, n=5) == 1/x - 1/(6*x**3) assert abs(x).series(x, oo, n=5, dir='+') == x assert abs(x).series(x, -oo, n=5, dir='-') == -x assert abs(-x).series(x, oo, n=5, dir='+') == x assert abs(-x).series(x, -oo, n=5, dir='-') == -x assert exp(x*log(x)).series(n=3) == \ 1 + x*log(x) + x**2*log(x)**2/2 + O(x**3*log(x)**3) # XXX is this right? If not, fix "ngot > n" handling in expr. p = Symbol('p', positive=True) assert exp(sqrt(p)**3*log(p)).series(n=3) == \ 1 + p**S('3/2')*log(p) + O(p**3*log(p)**3) assert exp(sin(x)*log(x)).series(n=2) == 1 + x*log(x) + O(x**2*log(x)**2)
def test_132_genf(): searcher = TileScope([Perm((0, 2, 1))], point_placements) spec = searcher.auto_search(smallest=True) spec = spec.expand_verified() av = Av([Perm((0, 2, 1))]) for i in range(10): assert set(av.of_length(i)) == set( gp.patt for gp in spec.generate_objects_of_size(i)) assert spec.random_sample_object_of_size(i).patt in av gf = spec.get_genf() gf = sympy.series(spec.get_genf(), n=15) x = sympy.Symbol("x") assert [gf.coeff(x, n) for n in range(13)] == [ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, ]
def test_airybiprime(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airybiprime(z), airybiprime) assert airybiprime(0) == 3**(S(1)/6)/gamma(S(1)/3) assert airybiprime(oo) == oo assert airybiprime(-oo) == 0 assert diff(airybiprime(z), z) == z*airybi(z) assert series(airybiprime(z), z, 0, 3) == ( 3**(S(1)/6)/gamma(S(1)/3) + 3**(S(5)/6)*z**2/(6*gamma(S(2)/3)) + O(z**3)) assert airybiprime(z).rewrite(hyper) == ( 3**(S(5)/6)*z**2*hyper((), (S(5)/3,), z**S(3)/9)/(6*gamma(S(2)/3)) + 3**(S(1)/6)*hyper((), (S(1)/3,), z**S(3)/9)/gamma(S(1)/3)) assert isinstance(airybiprime(z).rewrite(besselj), airybiprime) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(-S(1)/3, 2*(-t)**(S(3)/2)/3) + besselj(S(1)/3, 2*(-t)**(S(3)/2)/3))/3) assert airybiprime(z).rewrite(besseli) == ( sqrt(3)*(z**2*besseli(S(2)/3, 2*z**(S(3)/2)/3)/(z**(S(3)/2))**(S(2)/3) + (z**(S(3)/2))**(S(2)/3)*besseli(-S(2)/3, 2*z**(S(3)/2)/3))/3) assert airybiprime(p).rewrite(besseli) == ( sqrt(3)*p*(besseli(-S(2)/3, 2*p**(S(3)/2)/3) + besseli(S(2)/3, 2*p**(S(3)/2)/3))/3) assert expand_func(airybiprime(2*(3*z**5)**(S(1)/3))) == ( sqrt(3)*(z**(S(5)/3)/(z**5)**(S(1)/3) - 1)*airyaiprime(2*3**(S(1)/3)*z**(S(5)/3))/2 + (z**(S(5)/3)/(z**5)**(S(1)/3) + 1)*airybiprime(2*3**(S(1)/3)*z**(S(5)/3))/2)
def get_massless(exp,replace=[],n=3): if len(replace)>0: for _ in replace: A,B=_ exp=exp.subs(A,B) exp=exp.subs(Q,1/eps) return sp.series(exp,eps,0,n=n).subs(eps,1/Q).removeO()
def compute_conf_intervals_via_shock_poly(a_t, p_poly, d_poly, q_poly, num_coeffs, max_lag=100): # computes the confidence interval by rewriting the ts in shock form. # a_t: the residuals # p_poly: the AR polynomial. Should have constant 1. # q_poly: the MA polynomial. Should have constant 1. # num_coeffs: number of parameters used. You should count the estimated mean of the ts as a parameter. v = len(a_t) - num_coeffs var = sum(a_t**2) * (1 / v) if p_poly is None and q_poly is None and d_poly is None: const_shock = 1.96 * np.sqrt((var).astype(float)) return np.asarray([const_shock] * max_lag) # compute_memory_shock_terms if p_poly is None: p_poly = 1 if d_poly is None: d_poly = 1 if q_poly is None: q_poly = 1 shock_poly: poly = (series(q_poly / (d_poly * p_poly), x=B, x0=0, n=max_lag + 1)).as_expr().removeO().as_poly() shock_coeffs = shock_poly.coeffs() s_t = np.cumsum(np.flip(shock_coeffs)**2) std_errors = 1.96 * np.sqrt((var * s_t).astype(float)) return std_errors
def symbol_calc_2d_taylor(n, x_taylor="x1lin", order=2, x1_neg=True, slope="slope", Iext1="Iext1", shape=None): fx1ser, v = symbol_eqtn_fx1(n, model="2d", x1_neg=x1_neg, slope=slope, Iext1=Iext1)[1:] fx1ser = fx1ser.tolist() x_taylor = symbol_vars(n, [x_taylor])[0] v.update({"x_taylor": x_taylor}) for ix in range(shape_to_size(v["x1"].shape)): fx1ser[ix] = series(fx1ser[ix], x=v["x1"][ix], x0=x_taylor[ix], n=order).removeO() # fx1ser = Array(fx1ser) if shape is not None: if len(shape) > 1: fx1ser = fx1ser.reshape(shape[0], shape[1]) else: fx1ser = fx1ser.reshape(shape[0], ) return lambdify([ v["x1"], x_taylor, v["z"], v["y1"], v[Iext1], v[slope], v["a"], v["b"], v["d"], v["tau1"] ], fx1ser, "numpy"), fx1ser, v
def _series_expand(self, param, about, order): if isinstance(self.val, sympy.Basic): if about != 0: c = self.val.subs({param: about + param}) else: c = self.val series = sympy.series(c, x=param, x0=0, n=None) res = [] next_order = 0 for term in series: c, o = term.as_coeff_exponent(param) if o < 0 or o.is_noninteger: raise ValueError( "%s is singular at expansion point %s=%s." % (self, param, about) ) if o > order: break res.extend([0] * (o - next_order)) res.append(c) next_order = o + 1 res.extend([0] * (order + 1 - next_order)) return tuple([ScalarValue.create(c) for c in res]) else: return tuple([self] + [Zero] * order)
def Cauchy_form_poly(equations, X): #####Computing the Taylor polynomial####################### n = len(X) P_str = [Pi.replace('\n', '') for Pi in open(equations, 'r').readlines()] P_pluse = [P_stri for P_stri in P_str] P_minus = [P_stri for P_stri in P_str] for i in range(2, n): P_pluse = [ P_plusei.replace("x" + str(i + 1), "(x" + str(i + 1) + "+ r" + str(i + 1) + "*t)") for P_plusei in P_pluse ] P_minus = [ P_minusi.replace("x" + str(i + 1), "(x" + str(i + 1) + "- r" + str(i + 1) + "*t)") for P_minusi in P_minus ] DP = [("0.5*(" + P_plusei + "- (" + P_minusi + ") )").replace("^", "**") for P_plusei, P_minusi in zip(P_pluse, P_minus)] #X_Ball=list(parse_expr(DP[0]).free_symbols) #t_in= X_Ball.index(sp.Symbol('t')) #t=X_Ball[t_in] t = sp.Symbol('t') D_ser = [sp.series(parse_expr(DPi), t).removeO() for DPi in DP] D_ser = [sp.expand(seri / t) for seri in D_ser] D_ser = [seri.subs(t, sp.sqrt(t)) for seri in D_ser] return D_ser
def test_airyai(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airyai(z), airyai) assert airyai(0) == 3**(S(1)/3)/(3*gamma(S(2)/3)) assert airyai(oo) == 0 assert airyai(-oo) == 0 assert diff(airyai(z), z) == airyaiprime(z) assert series(airyai(z), z, 0, 3) == ( 3**(S(5)/6)*gamma(S(1)/3)/(6*pi) - 3**(S(1)/6)*z*gamma(S(2)/3)/(2*pi) + O(z**3)) assert airyai(z).rewrite(hyper) == ( -3**(S(2)/3)*z*hyper((), (S(4)/3,), z**S(3)/9)/(3*gamma(S(1)/3)) + 3**(S(1)/3)*hyper((), (S(2)/3,), z**S(3)/9)/(3*gamma(S(2)/3))) assert isinstance(airyai(z).rewrite(besselj), airyai) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(-S(1)/3, 2*(-t)**(S(3)/2)/3) + besselj(S(1)/3, 2*(-t)**(S(3)/2)/3))/3) assert airyai(z).rewrite(besseli) == ( -z*besseli(S(1)/3, 2*z**(S(3)/2)/3)/(3*(z**(S(3)/2))**(S(1)/3)) + (z**(S(3)/2))**(S(1)/3)*besseli(-S(1)/3, 2*z**(S(3)/2)/3)/3) assert airyai(p).rewrite(besseli) == ( sqrt(p)*(besseli(-S(1)/3, 2*p**(S(3)/2)/3) - besseli(S(1)/3, 2*p**(S(3)/2)/3))/3) assert expand_func(airyai(2*(3*z**5)**(S(1)/3))) == ( -sqrt(3)*(-1 + (z**5)**(S(1)/3)/z**(S(5)/3))*airybi(2*3**(S(1)/3)*z**(S(5)/3))/6 + (1 + (z**5)**(S(1)/3)/z**(S(5)/3))*airyai(2*3**(S(1)/3)*z**(S(5)/3))/2)
def main(k, terms): d = diff(func(x), x, k) print(d) a = series(d, x, n=terms) print("The derivative of the order {} with first {} terms in the Taylor series is \n{}".format(k, terms, a)) return a
def __init__(self, a, b, omega, gamma, Nmax): import time """ Initialize the object: do the Taylor series expansion etc """ self.a = a self.b = b # define symbols x, y, u = sy.symbols('x y u', real=True) # define a density function we want to integrate rho = sy.sin(omega * y) * sy.exp(gamma * y) # # make a Taylor series expansion of this density # up to Nmax terms rho_taylor = sy.series(rho, y, (a + b) / 2, Nmax).removeO() # Now we substitute y=u+x and represent the result as a polynomial wrt u pu_coeffs = rho_taylor.subs(y, u + x).as_poly(u).all_coeffs() self.pu_coeffs_str = [] for coeff in pu_coeffs: self.pu_coeffs_str.append(str(coeff)) # for evaluation we would like to convert these functions # to lambda-function, but those cannot be stored (pickled) # we will store the lambda functions in the following list: self.cns = []
def test_airyai(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airyai(z), airyai) assert airyai(0) == 3**Rational(1, 3)/(3*gamma(Rational(2, 3))) assert airyai(oo) == 0 assert airyai(-oo) == 0 assert diff(airyai(z), z) == airyaiprime(z) assert series(airyai(z), z, 0, 3) == ( 3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) - 3**Rational(1, 6)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3)) assert airyai(z).rewrite(hyper) == ( -3**Rational(2, 3)*z*hyper((), (Rational(4, 3),), z**3/9)/(3*gamma(Rational(1, 3))) + 3**Rational(1, 3)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3)))) assert isinstance(airyai(z).rewrite(besselj), airyai) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) + besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3) assert airyai(z).rewrite(besseli) == ( -z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(1, 3)) + (z**Rational(3, 2))**Rational(1, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3)/3) assert airyai(p).rewrite(besseli) == ( sqrt(p)*(besseli(Rational(-1, 3), 2*p**Rational(3, 2)/3) - besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3) assert expand_func(airyai(2*(3*z**5)**Rational(1, 3))) == ( -sqrt(3)*(-1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airybi(2*3**Rational(1, 3)*z**Rational(5, 3))/6 + (1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airyai(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
def test_airybiprime(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airybiprime(z), airybiprime) assert airybiprime(0) == 3**Rational(1, 6)/gamma(Rational(1, 3)) assert airybiprime(oo) is oo assert airybiprime(-oo) == 0 assert diff(airybiprime(z), z) == z*airybi(z) assert series(airybiprime(z), z, 0, 3) == ( 3**Rational(1, 6)/gamma(Rational(1, 3)) + 3**Rational(5, 6)*z**2/(6*gamma(Rational(2, 3))) + O(z**3)) assert airybiprime(z).rewrite(hyper) == ( 3**Rational(5, 6)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) + 3**Rational(1, 6)*hyper((), (Rational(1, 3),), z**3/9)/gamma(Rational(1, 3))) assert isinstance(airybiprime(z).rewrite(besselj), airybiprime) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) + besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3) assert airybiprime(z).rewrite(besseli) == ( sqrt(3)*(z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(2, 3) + (z**Rational(3, 2))**Rational(2, 3)*besseli(Rational(-2, 3), 2*z**Rational(3, 2)/3))/3) assert airybiprime(p).rewrite(besseli) == ( sqrt(3)*p*(besseli(Rational(-2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3) assert expand_func(airybiprime(2*(3*z**5)**Rational(1, 3))) == ( sqrt(3)*(z**Rational(5, 3)/(z**5)**Rational(1, 3) - 1)*airyaiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2 + (z**Rational(5, 3)/(z**5)**Rational(1, 3) + 1)*airybiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
def test_airybi(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airybi(z), airybi) assert airybi(0) == 3**(S(5)/6)/(3*gamma(S(2)/3)) assert airybi(oo) == oo assert airybi(-oo) == 0 assert diff(airybi(z), z) == airybiprime(z) assert series(airybi(z), z, 0, 3) == ( 3**(S(1)/3)*gamma(S(1)/3)/(2*pi) + 3**(S(2)/3)*z*gamma(S(2)/3)/(2*pi) + O(z**3)) assert airybi(z).rewrite(hyper) == ( 3**(S(1)/6)*z*hyper((), (S(4)/3,), z**S(3)/9)/gamma(S(1)/3) + 3**(S(5)/6)*hyper((), (S(2)/3,), z**S(3)/9)/(3*gamma(S(2)/3))) assert isinstance(airybi(z).rewrite(besselj), airybi) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(-S(1)/3, 2*(-t)**(S(3)/2)/3) + besselj(S(1)/3, 2*(-t)**(S(3)/2)/3))/3) assert airybi(z).rewrite(besseli) == ( sqrt(3)*(z*besseli(S(1)/3, 2*z**(S(3)/2)/3)/(z**(S(3)/2))**(S(1)/3) + (z**(S(3)/2))**(S(1)/3)*besseli(-S(1)/3, 2*z**(S(3)/2)/3))/3) assert airybi(p).rewrite(besseli) == ( sqrt(3)*sqrt(p)*(besseli(-S(1)/3, 2*p**(S(3)/2)/3) + besseli(S(1)/3, 2*p**(S(3)/2)/3))/3) assert expand_func(airybi(2*(3*z**5)**(S(1)/3))) == ( sqrt(3)*(1 - (z**5)**(S(1)/3)/z**(S(5)/3))*airyai(2*3**(S(1)/3)*z**(S(5)/3))/2 + (1 + (z**5)**(S(1)/3)/z**(S(5)/3))*airybi(2*3**(S(1)/3)*z**(S(5)/3))/2)
def expectation(self, expr, var, evaluate=True, **kwargs): """ Expectation of expression over distribution """ # TODO: support discrete sets with non integer stepsizes if evaluate: try: p = poly(expr, var) t = Dummy('t', real=True) mgf = self.moment_generating_function(t) deg = p.degree() taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t) result = 0 for k in range(deg+1): result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k) return result except PolynomialError: return summation(expr * self.pdf(var), (var, self.set.inf, self.set.sup), **kwargs) else: return Sum(expr * self.pdf(var), (var, self.set.inf, self.set.sup), **kwargs)
def euler76(): import sympy x=sympy.symbols("x") poly=1 for i in range(1,101): poly*=1/(1-x**i) print (sympy.series(poly,x,0,101)).coeff(x**100)-1
def expectation(self, expr, var, evaluate=True, **kwargs): """ Expectation of expression over distribution """ # TODO: support discrete sets with non integer stepsizes if evaluate: try: # note: in order for this algorithm to be valid, # the characteristic function must have continuous # derivatives up to the highest power of the variable in the expression p = poly(expr, var) t = Dummy('t', real=True) cf = self.characteristic_function(t) deg = p.degree() taylor = poly( series(cf.subs(t, t / I), t, 0, deg + 1).removeO(), t) result = 0 for k in range(deg + 1): result += p.coeff_monomial(var**k) * taylor.coeff_monomial( t**k) * factorial(k) return result except PolynomialError: return summation(expr * self.pdf(var), (var, self.set.inf, self.set.sup), **kwargs) else: return Sum(expr * self.pdf(var), (var, self.set.inf, self.set.sup), **kwargs)
def metric_expan(z, h, N): if N == 1: return (1, 1) else: g = 1 + z * h ig1 = sy.series(1 / g, x=h, n=N) return (g, ig1.removeO())
def poincare1d_BCH(): """ Calculations are not quite right, see Poincare1D.ipynb. """ from sympy import Symbol, Matrix, series, exp, var ncvar = lambda s: Symbol(s, commutative=False) A, B, C = map(ncvar, ['A', 'B', 'C']) chi, t0, x0 = var('chi,t0,x0') P = LieAlgebra([A, B, C], {1: [(A, B, C), (A, C, B)]}) BCH_series = sum([ term.simplify() for term in Dynkin_BCH( chi * A, (t0 * B + x0 * C), 6, commutator=P.commutator) ]) match_series = series(-chi / (1 - exp(chi)), chi, 0, 8) expr = lambda A, B, C: exp(chi * (A + (t0 - x0) / 2 * (B - C) - 1 / (1 - exp(chi)) * (t0 * B + x0 * C))) sexpr = expr(A, B, C) A = Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 0]]) B = Matrix([[0, 0, 1], [0, 0, 0], [0, 0, 0]]) C = Matrix([[0, 0, 0], [0, 0, 1], [0, 0, 0]]) mexpr = expr(A, B, C).simplify() return BCH_series, match_series, sexpr, (A, B, C), mexpr
def test_airyaiprime(): z = Symbol('z', real=False) t = Symbol('t', negative=True) p = Symbol('p', positive=True) assert isinstance(airyaiprime(z), airyaiprime) assert airyaiprime(0) == -3**(S(2)/3)/(3*gamma(S(1)/3)) assert airyaiprime(oo) == 0 assert diff(airyaiprime(z), z) == z*airyai(z) assert series(airyaiprime(z), z, 0, 3) == ( -3**(S(2)/3)/(3*gamma(S(1)/3)) + 3**(S(1)/3)*z**2/(6*gamma(S(2)/3)) + O(z**3)) assert airyaiprime(z).rewrite(hyper) == ( 3**(S(1)/3)*z**2*hyper((), (S(5)/3,), z**S(3)/9)/(6*gamma(S(2)/3)) - 3**(S(2)/3)*hyper((), (S(1)/3,), z**S(3)/9)/(3*gamma(S(1)/3))) assert isinstance(airyaiprime(z).rewrite(besselj), airyaiprime) assert airyai(t).rewrite(besselj) == ( sqrt(-t)*(besselj(-S(1)/3, 2*(-t)**(S(3)/2)/3) + besselj(S(1)/3, 2*(-t)**(S(3)/2)/3))/3) assert airyaiprime(z).rewrite(besseli) == ( z**2*besseli(S(2)/3, 2*z**(S(3)/2)/3)/(3*(z**(S(3)/2))**(S(2)/3)) - (z**(S(3)/2))**(S(2)/3)*besseli(-S(1)/3, 2*z**(S(3)/2)/3)/3) assert airyaiprime(p).rewrite(besseli) == ( p*(-besseli(-S(2)/3, 2*p**(S(3)/2)/3) + besseli(S(2)/3, 2*p**(S(3)/2)/3))/3) assert expand_func(airyaiprime(2*(3*z**5)**(S(1)/3))) == ( sqrt(3)*(z**(S(5)/3)/(z**5)**(S(1)/3) - 1)*airybiprime(2*3**(S(1)/3)*z**(S(5)/3))/6 + (z**(S(5)/3)/(z**5)**(S(1)/3) + 1)*airyaiprime(2*3**(S(1)/3)*z**(S(5)/3))/2)
def test_exp_product_positive_factors(): a, b = symbols("a, b", positive=True) x = a * b assert series( exp(x), x, n=8 ) == 1 + a * b + a ** 2 * b ** 2 / 2 + a ** 3 * b ** 3 / 6 + a ** 4 * b ** 4 / 24 + a ** 5 * b ** 5 / 120 + a ** 6 * b ** 6 / 720 + a ** 7 * b ** 7 / 5040 + O( a ** 8 * b ** 8, a, b )
def test_power_series_counts_language(re, i): dfa = rd.build_dfa(re) z, gfs = compute_generating_functions(*dfa) f = gfs[0] note(f) power_series = series(f, n=i + 1) counter = rd.LanguageCounter(*dfa) assert counter.count(i) == power_series.coeff(z, i)
def Validate(Butcher_dict, Butcher_key, yn, tn, rhs_key): # Set needed symbolic expressions t, dt = sp.symbols('t dt') # 1. First we solve the ODE exactly y = sp.Function('y') sol = sp.dsolve(sp.Eq(y(t).diff(t), rhs_dict[rhs_key](y(t), t)), y(t)).rhs constants = sp.solve([sol.subs(t,tn)-yn]) exact = sol.subs(constants) # 2. Now we solve the ODE numerically using specified Butcher table # Access the requested Butcher table Butcher = Butcher_dict[Butcher_key][0] # Determine number of predictor-corrector steps L = len(Butcher)-1 # Set a temporary array for update values k = np.zeros(L, dtype=object) # Initialize intermediate variable yhat = 0 # Initialize the updated solution ynp1 = 0 for i in range(L): #Initialize and approximate update for solution yhat = yn for j in range(i): # Update yhat for solution using a_ij Butcher table coefficients yhat += Butcher[i][j+1]*k[j] if Butcher_key == "DP8" or Butcher_key == "L6": yhat = 1.0*sp.N(yhat,20) # Otherwise the adding of fractions kills performance. # Determine the next corrector variable k_i using c_i Butcher table coefficients k[i] = dt*rhs_dict[rhs_key](yhat, tn + Butcher[i][0]*dt) # Update the solution at the next iteration ynp1 using Butcher table coefficients ynp1 += Butcher[L][i+1]*k[i] # Finish determining the solution for the next iteration ynp1 += yn # Determine the order of the RK method order = Butcher_dict[Butcher_key][1]+2 # Produces Taylor series of exact solution at t=tn about t = 0 with the specified order exact_series = sp.series(exact.subs(t, dt),dt, 0, order) num_series = sp.series(ynp1, dt, 0, order) diff = exact_series-num_series return diff
def __sections(self): t = sp.symbols('t') GenSec = sp.prod(1 / (1 - (t * zz)) for zz in self.coordinates) poly = sp.series(GenSec, t, n=self.dimensions + 1).coeff(t**(self.dimensions)) sections = [] while poly != 0: sections.append(sp.LT(poly)) poly = poly - sp.LT(poly) return (np.array(sections), len(sections))
def test_issue_5223(): assert series(1, x) == 1 assert next(S.Zero.lseries(x)) == 0 assert cos(x).series() == cos(x).series(x) raises(ValueError, lambda: cos(x + y).series()) raises(ValueError, lambda: x.series(dir="")) assert (cos(x).series(x, 1) - cos(x + 1).series(x).subs(x, x - 1)).removeO() == 0 e = cos(x).series(x, 1, n=None) assert [next(e) for i in range(2)] == [cos(1), -((x - 1) * sin(1))] e = cos(x).series(x, 1, n=None, dir="-") assert [next(e) for i in range(2)] == [cos(1), (1 - x) * sin(1)] # the following test is exact so no need for x -> x - 1 replacement assert abs(x).series(x, 1, dir="-") == x assert ( exp(x).series(x, 1, dir="-", n=3).removeO() == E - E * (-x + 1) + E * (-x + 1) ** 2 / 2 ) D = Derivative assert D(x ** 2 + x ** 3 * y ** 2, x, 2, y, 1).series(x).doit() == 12 * x * y assert next(D(cos(x), x).lseries()) == D(1, x) assert D(exp(x), x).series(n=3) == D(1, x) + D(x, x) + D(x ** 2 / 2, x) + D( x ** 3 / 6, x ) + O(x ** 3) assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4 * x assert (1 + x + O(x ** 2)).getn() == 2 assert (1 + x).getn() is None assert ((1 / sin(x)) ** oo).series() is oo logx = Symbol("logx") assert ((sin(x)) ** y).nseries(x, n=1, logx=logx) == exp(y * logx) + O( x * exp(y * logx), x ) assert sin(1 / x).series(x, oo, n=5) == 1 / x - 1 / (6 * x ** 3) + O( x ** (-5), (x, oo) ) assert abs(x).series(x, oo, n=5, dir="+") == x assert abs(x).series(x, -oo, n=5, dir="-") == -x assert abs(-x).series(x, oo, n=5, dir="+") == x assert abs(-x).series(x, -oo, n=5, dir="-") == -x assert exp(x * log(x)).series(n=3) == 1 + x * log(x) + x ** 2 * log(x) ** 2 / 2 + O( x ** 3 * log(x) ** 3 ) # XXX is this right? If not, fix "ngot > n" handling in expr. p = Symbol("p", positive=True) assert exp(sqrt(p) ** 3 * log(p)).series(n=3) == 1 + p ** S("3/2") * log(p) + O( p ** 3 * log(p) ** 3 ) assert exp(sin(x) * log(x)).series(n=2) == 1 + x * log(x) + O(x ** 2 * log(x) ** 2)
def t_expand(expr, max_deg): """ Takes an expression f(x,y) and computes the Taylor expansion in x and y up to bi-degree fixed by max_deg. For example: x / (1 - y) with value of max_deg = 3 will give x + x * y up to bi-degree 2. """ f = expr.subs([(x, t*x), (y, t*y)]) return series(f, t, 0, max_deg).removeO().subs(t, 1)
def test_issue_14885(): assert series(x ** Rational(-3, 2) * exp(x), x, 0) == ( x ** Rational(-3, 2) + 1 / sqrt(x) + sqrt(x) / 2 + x ** Rational(3, 2) / 6 + x ** Rational(5, 2) / 24 + x ** Rational(7, 2) / 120 + x ** Rational(9, 2) / 720 + x ** Rational(11, 2) / 5040 + O(x ** 6) )
def t_degree(expr, max_deg): """ Takes an expression f(x,y) and computes the Taylor expansion in x and y up to bi-degree fixed by max_deg. Then, picks the term of highest bi-degree, and returns the value of the degree. For example: x / (1 - y) with value of max_deg = 3 will give t * x + t**2 * x * y up to bi-degree 2. Will return 2. """ f = expr.subs([(x, t*x), (y, t*y)]) return degree(series(f, t, 0, max_deg).removeO(), t)
def t_min_degree(expr, max_deg, large_number=1000): """ Takes an expression f(x,y) and computes the Taylor expansion in x and y up to bi-degree fixed by max_deg. Then, picks the term of lowest bi-degree. For example: x / (1 - y) with value of max_deg = 3 will give t * x + t**2 * x * y up to bi-degree 2. Will return x. """ f = expr.subs([(x, x / t), (y, y / t)]) f_t_series = t**large_number * series(f, t, 0, max_deg).removeO() leading_term = LT(f_t_series.expand(), t).subs(t, 1) return leading_term
def expectation(self, expr, var, evaluate=True, **kwargs): """ Expectation of expression over distribution """ if evaluate: try: p = poly(expr, var) t = Dummy('t', real=True) mgf = self._moment_generating_function(t) if mgf is None: return integrate(expr * self.pdf(var), (var, self.set), **kwargs) deg = p.degree() taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t) result = 0 for k in range(deg+1): result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k) return result except PolynomialError: return integrate(expr * self.pdf(var), (var, self.set), **kwargs) else: return Integral(expr * self.pdf(var), (var, self.set), **kwargs)
def _get_dict(self, other): """ Returns a dictionary representing the (exponent, coefficient) pairs of the Puiseux series expansion of `other`. If `other` is a `PuiseuxSeries` then we take the minimum order of `other` and self. If `other is a SymPy expression then we compute the Taylor series in (x-alpha) of other up to `self.order`. """ # if other is a Puiseux series (also centered at self.alpha) # then the order of the new puiseux series is the smaller of # the two if isinstance(other, PuiseuxSeries): if self.alpha != other.alpha: raise ValueError("Puiseux series must be centered at " + \ "the same point.") order = min(self.order, other.order) d = other.d # if other is a SymPy Expr then compute the series expansion # of other up to self's order and store the exponent, coeff # pairs in d elif isinstance(other, sympy.Expr): d = {} order = self.order s = sympy.series(other, self.var, x0=self.alpha, n=None) for term in s: # we have to shift because SymPy has trouble # collecting expressions such as c*(x-a) in terms of # (x-a). Example: 1-x should be -1*(x-1) but SymPy # cannot detect this. term = term.subs(x,x+self.alpha) coeff, exp = term.as_coeff_exponent(self.var) if exp < order: d[exp] = coeff else: break return order,d
def get_coefficients(function, p, x0, n): taylor_series = sp.series(expr=function, x=p, x0=x0, n=n).removeO() coefficients_dict_sympy_pow_keys = taylor_series.as_coefficients_dict() coefficients_dict_string_keys = {} for key in coefficients_dict_sympy_pow_keys.keys(): coefficients_dict_string_keys[str(key)] = coefficients_dict_sympy_pow_keys[key] taylor_coefficients = [] for i in range(n): if i == 0: key = '1' elif i == 1: key = 'p' else: key = "(p - 0.5)**{}".format(i) taylor_coefficients.append( coefficients_dict_string_keys[key] / (2**i) ) coeffs = [ sp.N(c, precision) for c in taylor_coefficients ] return coeffs
def test_cos(): e1 = cos(x).series(x, 0) e2 = series(cos(x), x, 0) assert e1 == e2
def test_issue_15539(): assert series(atan(x), x, -oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x - pi/2 + O(x**(-6), (x, -oo))) assert series(atan(x), x, oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x + pi/2 + O(x**(-6), (x, oo)))
def test_issue_14885(): assert series(x**(-S(3)/2)*exp(x), x, 0) == (x**(-S(3)/2) + 1/sqrt(x) + sqrt(x)/2 + x**(S(3)/2)/6 + x**(S(5)/2)/24 + x**(S(7)/2)/120 + x**(S(9)/2)/720 + x**(S(11)/2)/5040 + O(x**6))
sym_DxyyyG_near = pickle.load(open(prefix+'DxyyyG_near.dat','r')) sym_DyyyyG_near = pickle.load(open(prefix+'DyyyyG_near.dat','r')) sym_DxxxxxG_near = pickle.load(open(prefix+'DxxxxxG_near.dat','r')) sym_DxxxxyG_near = pickle.load(open(prefix+'DxxxxyG_near.dat','r')) sym_DxxxyyG_near = pickle.load(open(prefix+'DxxxyyG_near.dat','r')) sym_DxxyyyG_near = pickle.load(open(prefix+'DxxyyyG_near.dat','r')) sym_DxyyyyG_near = pickle.load(open(prefix+'DxyyyyG_near.dat','r')) sym_DyyyyyG_near = pickle.load(open(prefix+'DyyyyyG_near.dat','r')) print "Complete." else: print "Calculating derivatives of kernel symbolically..." rr = x**2 + y**2 rho = rr / delta**2 sym_DxG = x*(sp.exp( - rho ) - 1 )/(2*sp.pi*rr) sym_DyG = y*(sp.exp( - rho ) - 1 )/(2*sp.pi*rr) sym_DxG_near = sp.series(sp.series(sym_DxG,x).removeO()\ ,y).removeO() sym_DyG_near = sp.series(sp.series(sym_DyG,x).removeO()\ ,y).removeO() pickle.dump(sym_DxG,open(prefix+'DxG.dat','w')) pickle.dump(sym_DyG,open(prefix+'DyG.dat','w')) pickle.dump(sym_DxG_near,open(prefix+'DxG_near.dat','w')) pickle.dump(sym_DyG_near,open(prefix+'DyG_near.dat','w')) print "Computed first order derivatives" sym_DxxG = sp.diff( sym_DxG , x ) sym_DxyG = sp.diff( sym_DxG , y ) sym_DyyG = sp.diff( sym_DyG , y ) sym_DxxG_near = sp.series(sp.series(sym_DxxG,x).removeO()\ ,y).removeO() sym_DxyG_near = sp.series(sp.series(sym_DxyG,x).removeO()\ ,y).removeO() sym_DyyG_near = sp.series(sp.series(sym_DyyG,x).removeO()\
def exercise_5_3(): u, z = sp.symbols('u, z') quadratic = z*u**2 - u + z u_of_z = sp.simplify(sp.solve(quadratic, u)[0]) sp.pprint(u_of_z) sp.pprint(sp.series(u_of_z, z, 0, 13), num_columns=100)
def test_sin(): e1 = sin(x).series(x, 0) e2 = series(sin(x), x, 0) assert e1 == e2
def test_exp_product_positive_factors(): a, b = symbols('a, b', positive=True) x = a * b assert series(exp(x), x, n=8) == 1 + a*b + a**2*b**2/2 + \ a**3*b**3/6 + a**4*b**4/24 + a**5*b**5/120 + a**6*b**6/720 + \ a**7*b**7/5040 + O(a**8*b**8, a, b)
def test_issue_8805(): assert series(1, n=8) == 1
def test_issue_10761(): assert series(1/(x**-2 + x**-3), x, 0) == x**3 - x**4 + x**5 + O(x**6)
def exercise_5_1(): z = sp.symbols('z') sp.pprint(sp.series((1+z+z**2)/(1-z-z**2-z**3),z,0,10), num_columns=100)
def test_exp(): e1 = exp(x).series(x, 0) e2 = series(exp(x), x, 0) assert e1 == e2
def test_issue_7203(): assert series(cos(x), x, pi, 3) == \ -1 + (x - pi)**2/2 + O((x - pi)**3, (x, pi))
def test_exp2(): e1 = exp(cos(x)).series(x, 0) e2 = series(exp(cos(x)), x, 0) assert e1 == e2
def test_issue_5852(): assert series(1/cos(x/log(x)), x, 0) == 1 + x**2/(2*log(x)**2) + \ 5*x**4/(24*log(x)**4) + O(x**6)
from matplotlib import animation #plt.rcParams['animation.ffmpeg_path'] = "C:/ffmpeg/bin/ffmpeg.exe" fig = plt.figure() x = Symbol('x') f = exp((sin(x) - cos(x)) / 4) / (x ** 2 + 10) xdata = np.linspace(-10, 10, 200) ydata = lambdify(x, f, "numpy")(xdata) y0 = lambdify(x, f, "numpy")(0) orders = 10 yydata = [] for o in range(orders): dl = series(f, x, 0, o + 1).removeO() if o == 0: yydata.append([y0] * len(xdata)) else: yydata.append(lambdify(x, dl, "numpy")(xdata)) func, = plt.plot(xdata, ydata, color="b") dl, = plt.plot([], [], color="g") point, = plt.plot([], [], color="r", marker='.', markersize=10) legend_func = plt.text(-9, 0.10, r"", {'color': 'b', 'fontsize': 16}) legend_dl = plt.text(-9, 0.08, r"", {'color': 'g', 'fontsize': 16}) def init(): func.set_data([], [])
from sympy import Symbol, Rational, cos, sin, series x = Symbol('x') print cos(x).series(x, 0.5, 10) print cos(x).series(x, 0.5, 10).removeO() from sympy.series import series print series(cos(x), x0=Rational(0.5), n=10) print series(cos(x), x0=0, n=10)