def ode_is_lin_const_coeff(ode_symbol, ode_definition, shapes): """ TODO: improve the original code: the function should take a list of shape names, not objects :param ode_symbol string encoding the LHS :param ode_definition string encoding RHS :param shapes A list with shape names :return true iff the ode definition is a linear and constant coefficient ODE """ ode_symbol_sp = parse_expr(ode_symbol) ode_definition_sp = parse_expr(ode_definition) # Check linearity ddvar = diff(diff(ode_definition_sp, ode_symbol_sp), ode_symbol_sp) if simplify(ddvar) != 0: return False # Check coefficients dvar = diff(ode_definition_sp, ode_symbol_sp) for shape in shapes: for symbol in dvar.free_symbols: if shape == str(symbol): return False return True
def get_source_cmb_cl(params, CMB_unit='muK'): r""" Get the angular power spectrum of emission angle and time delay sources :math:`\psi_t`, :math:`\psi_\zeta`, as well as the perpendicular velocity and E polarization. All are returned with 1 and 2 versions, for recombination and reionization respectively. Note that this function destroys any custom sources currently configured. :param params: :class:`.model.CAMBparams` instance with cosmological parameters etc. :param CMB_unit: scale results from dimensionless, use 'muK' for :math:`\mu K^2` units :return: dictionary of power spectra, with :math:`L(L+1)/2\pi` factors. """ import sympy from sympy import diff from . import symbolic as cs assert (np.isclose(params.omk, 0)) angdist = cs.tau0 - cs.t emission_sources = { 'vperp': -(cs.sigma + cs.v_b) * cs.visibility / cs.k / angdist, 'emit': 15 * diff(cs.polter * cs.visibility, cs.t) / 8 / cs.k ** 2 / angdist, 'delay': 15 * diff(cs.polter * cs.visibility, cs.t) / 8 / cs.k ** 2 / angdist ** 2 * (cs.tau0 - cs.tau_maxvis), 'E': cs.scalar_E_source} sources = {} for key, source in list(emission_sources.items()): sources[key + '1'] = sympy.Piecewise((source, 1 / cs.a - 1 > 30), (0, True)) # recombination sources[key + '2'] = sympy.Piecewise((source, 1 / cs.a - 1 <= 30), (0, True)) # reionization params.set_custom_scalar_sources(sources, source_ell_scales={'E1': 2, 'E2': 2}) return camb.get_results(params).get_cmb_unlensed_scalar_array_dict(CMB_unit=CMB_unit)
def lhs_eq(t, m, b, s, u, damping='linear'): """Return lhs of differential equation as sympy expression.""" v = sm.diff(u, t) if damping == 'linear': return m*sm.diff(u, t, t) + b*v + s(u) else: return m*sm.diff(u, t, t) + b*v*sm.Abs(v) + s(u)
def __init__(self, nddistr=None, d=None): super(TwoVarsModel, self).__init__(nddistr, [d]) self.eliminate_other([d]) self.d = d self.vars = [] self.symvars = [] for var in nddistr.Vars: #self.free_rvs: self.vars.append(var) self.symvars.append(var.getSymname()) #print "=====", self.vars #print self.symvars #print self.dep_rvs #print self.rv_to_equation self.symop = self.rv_to_equation[d] if len(self.vars) != 2: raise Exception("use it with two variables") x = self.symvars[0] y = self.symvars[1] z = sympy.Symbol("z") self.fun_alongx = eq_solve(self.symop, z, y)[0] self.fun_alongy = eq_solve(self.symop, z, x)[0] self.lfun_alongx = my_lambdify([x, z], self.fun_alongx, "numpy") self.lfun_alongy = my_lambdify([y, z], self.fun_alongy, "numpy") self.Jx = 1 * sympy.diff(self.fun_alongx, z) #print "Jx=", self.Jx #print "fun_alongx=", self.fun_alongx self.Jy = 1 * sympy.diff(self.fun_alongy, z) self.lJx = my_lambdify([x, z], self.Jx, "numpy") self.lJy = my_lambdify([y, z], self.Jy, "numpy") self.z = z
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_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_atan2(): assert atan2(0, 0) == S.NaN assert atan2(0, 1) == 0 assert atan2(1, 1) == pi/4 assert atan2(1, 0) == pi/2 assert atan2(1, -1) == 3*pi/4 assert atan2(0, -1) == pi assert atan2(-1, -1) == -3*pi/4 assert atan2(-1, 0) == -pi/2 assert atan2(-1, 1) == -pi/4 u = Symbol("u", positive=True) assert atan2(0, u) == 0 u = Symbol("u", negative=True) assert atan2(0, u) == pi assert atan2(y, oo) == 0 assert atan2(y, -oo)== 2*pi*Heaviside(re(y)) - pi assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2)) assert atan2(y, x).rewrite(atan) == 2*atan(y/(x + sqrt(x**2 + y**2))) assert diff(atan2(y, x), x) == -y/(x**2 + y**2) assert diff(atan2(y, x), y) == x/(x**2 + y**2) assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2) assert simplify(diff(atan2(y, x).rewrite(log), y)) == x/(x**2 + y**2) assert isinstance(atan2(2, 3*I).n(), atan2)
def test_derivative_appellf1(): from sympy import diff a, b1, b2, c, x, y, z = symbols('a b1 b2 c x y z') assert diff(appellf1(a, b1, b2, c, x, y), x) == a*b1*appellf1(a + 1, b2, b1 + 1, c + 1, y, x)/c assert diff(appellf1(a, b1, b2, c, x, y), y) == a*b2*appellf1(a + 1, b1, b2 + 1, c + 1, x, y)/c assert diff(appellf1(a, b1, b2, c, x, y), z) == 0 assert diff(appellf1(a, b1, b2, c, x, y), a) == Derivative(appellf1(a, b1, b2, c, x, y), a)
def test_derivative_evaluate(): assert Derivative(sin(x), x) != diff(sin(x), x) assert Derivative(sin(x), x).doit() == diff(sin(x), x) assert Derivative(Derivative(f(x), x), x) == diff(f(x), x, x) assert Derivative(sin(x), x, 0) == sin(x) assert Derivative(sin(x), (x, y), (x, -y)) == sin(x)
def __init__(self): self.num_lines, self.num_marks = 5, 2 self._qp = {} function_types = ['product', 'quotient', 'composite'] function_type = random.choice(function_types) if function_type == 'product': # 2008 1b: y = x * e**(3x), a = 0 # 2011 1b: y = x**2 * sin(2x), a = pi / 6 self.create_product_differentiation() elif function_type == 'quotient': # 2009 1b: y = cos(x) / (2x + 2), a = pi # 2012 1b: y = x / sin(x), a = pi / 2 self.create_quotient_differentiation() elif function_type == 'composite': # I thought of including sin and cos, but I can't remember ever seeing a question where a quadratic was nested inside # of a trig function self.create_composite_differentiation() if function_type == 'quotient': # quotients are always written as one big fraction, but sympy always separates them into multiple fractions, so we have to factorise self._qp['derivative'] = sympy.diff(self._qp['equation']).together() else: self._qp['derivative'] = sympy.diff(self._qp['equation']) self._qp['answer'] = self._qp['derivative'].subs({x: self._qp['x_value']})
def __init__(self): self.num_lines, self.num_marks = 5, 2 self._qp = {} function_type = random.choice(['sqrt', 'quadratic', 'product']) if function_type == 'sqrt': outer_function = all_functions.request_linear(difficulty=2).equation inner_function = all_functions.request_linear(difficulty=1).equation inner_function = inner_function.replace(lambda expr: expr.is_Symbol, lambda expr: sympy.sqrt(expr)) self._qp['equation'] = outer_function.replace(x, inner_function) self._qp['derivative'] = sympy.diff(self._qp['equation']) elif function_type == 'quadratic': power_two_coeff = not_named_yet.randint_no_zero(-3, 3) power_one_coeff = not_named_yet.randint_no_zero(-5, 5) inner_function = power_two_coeff * x ** 2 + power_one_coeff * x index = random.randint(3, 5) self._qp['equation'] = inner_function ** index self._qp['derivative'] = sympy.diff(self._qp['equation']) elif function_type == 'product': left_function = x ** random.randint(1, 3) right_outer_function = random.choice([sympy.sin, sympy.cos, sympy.log, sympy.exp]) right_inner_function = not_named_yet.randint_no_zero(-3, 3) * x self._qp['equation'] = left_function * right_outer_function(right_inner_function) self._qp['derivative'] = sympy.diff(self._qp['equation'])
def case0(f, N=3): B = 1 - x ** 3 dBdx = sm.diff(B, x) # Compute basis functions and their derivatives phi = {0: [x ** (i + 1) * (1 - x) for i in range(N + 1)]} phi[1] = [sm.diff(phi_i, x) for phi_i in phi[0]] def integrand_lhs(phi, i, j): return phi[1][i] * phi[1][j] def integrand_rhs(phi, i): return f * phi[0][i] - dBdx * phi[1][i] Omega = [0, 1] u_bar = solve(integrand_lhs, integrand_rhs, phi, Omega, verbose=True, numint=False) u = B + u_bar print "solution u:", sm.simplify(sm.expand(u)) # Calculate analytical solution # Solve -u''=f by integrating f twice f1 = sm.integrate(f, x) f2 = sm.integrate(f1, x) # Add integration constants C1, C2 = sm.symbols("C1 C2") u_e = -f2 + C1 * x + C2 # Find C1 and C2 from the boundary conditions u(0)=0, u(1)=1 s = sm.solve([u_e.subs(x, 0) - 1, u_e.subs(x, 1) - 0], [C1, C2]) # Form the exact solution u_e = -f2 + s[C1] * x + s[C2] print "analytical solution:", u_e # print 'error:', u - u_e # many terms - which cancel print "error:", sm.expand(u - u_e)
def test_gegenbauer(): n = Symbol("n") a = Symbol("a") assert gegenbauer(0, a, x) == 1 assert gegenbauer(1, a, x) == 2*a*x assert gegenbauer(2, a, x) == -a + x**2*(2*a**2 + 2*a) assert gegenbauer(3, a, x) == \ x**3*(4*a**3/3 + 4*a**2 + 8*a/3) + x*(-2*a**2 - 2*a) assert gegenbauer(-1, a, x) == 0 assert gegenbauer(n, S(1)/2, x) == legendre(n, x) assert gegenbauer(n, 1, x) == chebyshevu(n, x) assert gegenbauer(n, -1, x) == 0 X = gegenbauer(n, a, x) assert isinstance(X, gegenbauer) assert gegenbauer(n, a, -x) == (-1)**n*gegenbauer(n, a, x) assert gegenbauer(n, a, 0) == 2**n*sqrt(pi) * \ gamma(a + n/2)/(gamma(a)*gamma(-n/2 + S(1)/2)*gamma(n + 1)) assert gegenbauer(n, a, 1) == gamma(2*a + n)/(gamma(2*a)*gamma(n + 1)) assert gegenbauer(n, Rational(3, 4), -1) == zoo m = Symbol("m", positive=True) assert gegenbauer(m, a, oo) == oo*RisingFactorial(a, m) assert conjugate(gegenbauer(n, a, x)) == gegenbauer(n, conjugate(a), conjugate(x)) assert diff(gegenbauer(n, a, x), n) == Derivative(gegenbauer(n, a, x), n) assert diff(gegenbauer(n, a, x), x) == 2*a*gegenbauer(n - 1, a + 1, x)
def __init__(self, fi=lambda t, theta: log(t), fi_inv=None, #lambda t, theta:(-sympy.log(t)) ** theta, theta=2, marginals=None): self.theta = float(theta)#Symbol('theta') self.t = Symbol('t') self.s = Symbol('s') self.d = len(marginals) self.fi_ = fi self.fi_inv_ = fi_inv self.sym_fi = fi(self.t, self.theta) self.sym_fi_deriv = sympy.diff(self.sym_fi, self.t) if fi_inv is None: self.sym_fi_inv = sympy.solve(self.sym_fi - self.s, self.t)[0] else: self.sym_fi_inv = fi_inv(self.s, self.theta) self.sym_fi_inv_nth_deriv = sympy.diff(self.sym_fi_inv, self.s, self.d) #self.debug_info() super(ArchimedeanSymbolicCopula, self).__init__(fi=sympy.lambdify(self.t, self.sym_fi, "numpy"), fi_deriv=sympy.lambdify(self.t, self.sym_fi_deriv, "numpy"), fi_inv=sympy.lambdify(self.s, self.sym_fi_inv, "numpy"), fi_inv_nth_deriv=sympy.lambdify(self.s, self.sym_fi_inv_nth_deriv, "numpy"), marginals=marginals) vars = self.symVars si = 0 for i in range(self.d): si += self.fi_(vars[i], self.theta) self.sym_C = self.fi_inv_(si, self.theta)
def grad(self, func): """ Calculate the gradient of 'func'. """ return Matrix([diff(func, self.xs[0]) / self.h[0], \ diff(func, self.xs[1]) / self.h[1], \ diff(func, self.xs[2]) / self.h[2]])
def test_Ynm(): # http://en.wikipedia.org/wiki/Spherical_harmonics th, ph = Symbol("theta", real=True), Symbol("phi", real=True) from sympy.abc import n, m assert Ynm(0, 0, th, ph).expand(func=True) == 1 / (2 * sqrt(pi)) assert Ynm(1, -1, th, ph) == -exp(-2 * I * ph) * Ynm(1, 1, th, ph) assert Ynm(1, -1, th, ph).expand(func=True) == sqrt(6) * sin(th) * exp(-I * ph) / (4 * sqrt(pi)) assert Ynm(1, -1, th, ph).expand(func=True) == sqrt(6) * sin(th) * exp(-I * ph) / (4 * sqrt(pi)) assert Ynm(1, 0, th, ph).expand(func=True) == sqrt(3) * cos(th) / (2 * sqrt(pi)) assert Ynm(1, 1, th, ph).expand(func=True) == -sqrt(6) * sin(th) * exp(I * ph) / (4 * sqrt(pi)) assert Ynm(2, 0, th, ph).expand(func=True) == 3 * sqrt(5) * cos(th) ** 2 / (4 * sqrt(pi)) - sqrt(5) / (4 * sqrt(pi)) assert Ynm(2, 1, th, ph).expand(func=True) == -sqrt(30) * sin(th) * exp(I * ph) * cos(th) / (4 * sqrt(pi)) assert Ynm(2, -2, th, ph).expand(func=True) == ( -sqrt(30) * exp(-2 * I * ph) * cos(th) ** 2 / (8 * sqrt(pi)) + sqrt(30) * exp(-2 * I * ph) / (8 * sqrt(pi)) ) assert Ynm(2, 2, th, ph).expand(func=True) == ( -sqrt(30) * exp(2 * I * ph) * cos(th) ** 2 / (8 * sqrt(pi)) + sqrt(30) * exp(2 * I * ph) / (8 * sqrt(pi)) ) assert diff(Ynm(n, m, th, ph), th) == ( m * cot(th) * Ynm(n, m, th, ph) + sqrt((-m + n) * (m + n + 1)) * exp(-I * ph) * Ynm(n, m + 1, th, ph) ) assert diff(Ynm(n, m, th, ph), ph) == I * m * Ynm(n, m, th, ph) assert conjugate(Ynm(n, m, th, ph)) == (-1) ** (2 * m) * exp(-2 * I * m * ph) * Ynm(n, m, th, ph) assert Ynm(n, m, -th, ph) == Ynm(n, m, th, ph) assert Ynm(n, m, th, -ph) == exp(-2 * I * m * ph) * Ynm(n, m, th, ph) assert Ynm(n, -m, th, ph) == (-1) ** m * exp(-2 * I * m * ph) * Ynm(n, m, th, ph)
def __call__(self, scalar_field): """ Represents the gradient of the given scalar field. Parameters ========== scalar_field : SymPy expression The scalar field to calculate the gradient of. Examples ======== >>> from sympy.vector import CoordSysCartesian >>> C = CoordSysCartesian('C') >>> C.delop(C.x*C.y*C.z) C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k """ scalar_field = express(scalar_field, self.system, variables = True) vx = diff(scalar_field, self._x) vy = diff(scalar_field, self._y) vz = diff(scalar_field, self._z) return vx*self._i + vy*self._j + vz*self._k
def boundary_layer1D(): import sympy as sym x, Pe = sym.symbols("x Pe") def u(x, Pe, module): return (1 - module.exp(x * Pe)) / (1 - module.exp(Pe)) u_formula = u(x, Pe, sym) ux_formula = sym.diff(u_formula, x) uxx_formula = sym.diff(ux_formula, x) print ux_formula, uxx_formula print "u_x:", sym.simplify(ux_formula.subs(x, 1)) print sym.simplify(ux_formula.subs(x, 1)).series(Pe, 0, 3) print "u_xx:", sym.simplify(uxx_formula.subs(x, 1)) print sym.simplify(uxx_formula.subs(x, 1)).series(Pe, 0, 3) import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 1, 10001) Pe = 1 u_num1 = u(x, Pe, np) Pe = 50 u_num2 = u(x, Pe, np) plt.plot(x, u_num1, x, u_num2) plt.legend(["Pe=1", "Pe=50"], loc="upper left") plt.savefig("tmp.png") plt.savefig("tmp.pdf") plt.axis([0, 1, -0.1, 1]) plt.show()
def boundary_layer1D_scale2(): import sympy as sym x, Pe = sym.symbols("x Pe") def u(x, Pe, module): return (1 - module.exp(x)) / (1 - module.exp(Pe)) u_formula = u(x, Pe, sym) ux_formula = sym.diff(u_formula, x) uxx_formula = sym.diff(ux_formula, x) print ux_formula, uxx_formula print "u_x:", sym.simplify(ux_formula.subs(x, Pe)) print sym.simplify(ux_formula).series(Pe, 0, 3) print "u_xx:", sym.simplify(uxx_formula.subs(x, Pe)) print sym.simplify(uxx_formula).series(Pe, 0, 3) import matplotlib.pyplot as plt import numpy as np Pe_values = [1, 10, 25, 50] for Pe in Pe_values: x = np.linspace(0, Pe, 10001) u_num = u(x, Pe, np) plt.plot(x, u_num) plt.legend(["Pe=%d" % Pe for Pe in Pe_values], loc="lower left") plt.savefig("tmp.png") plt.savefig("tmp.pdf") plt.axis([0, max(Pe_values), -0.4, 1]) plt.show()
def update_parameter_data(cx_str, cy_str, t): # string parsing cx_fun, cx_sym = my_bokeh_utils.string_to_function_parser(cx_str, ['t']) cy_fun, cy_sym = my_bokeh_utils.string_to_function_parser(cy_str, ['t']) from sympy import diff dcx_sym = diff(cx_sym, 't') dcy_sym = diff(cy_sym, 't') dcx_fun = my_bokeh_utils.sym_to_function_parser(dcx_sym, 't') dcy_fun = my_bokeh_utils.sym_to_function_parser(dcy_sym, 't') # crating sample x_val = cx_fun(t) y_val = cy_fun(t) dx_val = dcx_fun(t) dy_val = dcy_fun(t) xx, hx = np.linspace(source_view.data['x_start'][0], source_view.data['x_end'][0], curveintegral_settings.n_sample, retstep=True) ssdict, spdict, _ = my_bokeh_utils.quiver_to_data(x=np.array(x_val), y=np.array(y_val), u=np.array(dx_val), v=np.array(dy_val), h=2*hx, do_normalization=True, fix_at_middle=False) # save data source_param.data = dict(x=[x_val], y=[y_val], t=[t], x0=ssdict['x0'], y0=ssdict['y0'], x1=ssdict['x1'], y1=ssdict['y1'], xs=spdict['xs'], ys=spdict['ys']) print "curve point was updated with t=%f" % (t)
def _extract_linear_components(expr, dvars): # TODO replace by helpers.extract_linear_components? # Those are the variables in the expression, inserted by the edge # discretizer. assert is_affine_linear(expr, dvars) # Get the coefficients of u0, u1. coeff00 = sympy.diff(expr, dvars[0]) coeff01 = sympy.diff(expr, dvars[1]) x0 = sympy.Symbol('x0') x1 = sympy.Symbol('x1') # Now construct the coefficients for the other way around. coeff10 = coeff01 coeff10 = _swap(coeff10, dvars[0], dvars[1]) coeff10 = _swap(coeff10, x0, x1) coeff11 = coeff00 coeff11 = _swap(coeff11, dvars[0], dvars[1]) coeff11 = _swap(coeff11, x0, x1) affine = expr.subs([(dvars[0], 0), (dvars[1], 0)]) return ( [[coeff00, coeff01], [coeff10, coeff11]], [affine, affine] )
def differentiate(C,a, b): diff1 = [0]*N diff1_anal = [0]*N diff2 = [0]*N diff2_anal = [0]*N i = arange(N) # Chebyshev nodes on [-1,1] x = -cos(pi*(2.0*i + 1.0)/(2.0*(N-1) + 2.0)) #chebdiff1 = pow(2,1-i)*i*sin(i*arccos(x))/pow(1-x*x,0.5) #chebdiff2 = pow(2,1-i)*i*( x*sin(i*arccos(x))/pow(1-x*x,1.5) - i*cos(i*arccos(x))/(1-x*x)) # scale to physical interval [a,b] xp = affineTransform(x, a, b) c = 2.0/(b-a) for i in range(0,N): for j in range(0, N): tmp = pow(2,1-j)*j*sin(j*arccos(x[i]))/pow(1-x[i]*x[i],0.5) diff1[i] += c*C[j]*tmp tmp = pow(2,1-j)*j*( x[i]*sin(j*arccos(x[i]))/pow(1-x[i]*x[i],1.5) - j*cos(j*arccos(x[i]))/(1-x[i]*x[i])) diff2[i] += c*c*C[j]*tmp diff1_anal[i] = (sympy.diff(sympy.exp(-sympy.abc.x*sympy.abc.x*beta), sympy.abc.x, 1)).subs(sympy.abc.x,xp[i]) diff2_anal[i] = (sympy.diff(sympy.exp(-sympy.abc.x*sympy.abc.x*beta), sympy.abc.x, 2)).subs(sympy.abc.x,xp[i]) # plot the Chebyshev nodes and the interpolation plot(xp, diff1, 'r--', label = "chebyshev derivative ord 1") plot(xp, diff1_anal, 'g.', label = "analytic derivative ord 1") plot(xp, diff2, 'y--', label = "chebyshev derivative ord 2") plot(xp, diff2_anal, 'b*', label = "analytic derivative ord 2") legend(loc="best") grid(True) show()
def Delp2(f): """ Laplacian in X-Z """ d2fdx2 = diff(f, x, 2) d2fdz2 = diff(f, z, 2) return d2fdx2 + d2fdz2
def eleq(Lagrangian, Friction = 0, t = Symbol('t')): """ Returns Euler-Lagrange equations of the lagrangian system. Examples ======== >>> from sympy import * >>> t, k = symbols('t k') >>> x = symbols('x', cls=Function) >>> eleq(diff(x(t),t)**2/2 - k*x(t)**2/2) {a_x: -k*x} >>> a = symbols('a') >>> eleq(diff(x(t),t)**2/2 - k*x(t)**2/2, a*diff(x(t),t)**2/2) {a_x: -*a*v_x - k*x} """ Lagrangian = simplify(Lagrangian) var_list = [list(x.atoms(Function))[0] for x in Lagrangian.atoms(Derivative)] nvar = len(var_list) ecu_list = [ diff(Lagrangian, variable) - diff(Lagrangian, diff(variable,t), t) - diff(Friction, diff(variable,t)) for variable in var_list ] str_list = [ str(variable).replace("("+str(t)+")","") for variable in var_list ] a_subs = {diff(var_list[i],t,2): Symbol('a_' + str_list[i]) for i in range(nvar)} v_subs = {diff(var_list[i],t): Symbol('v_' + str_list[i]) for i in range(nvar)} x_subs = {var_list[i]: Symbol(str_list[i]) for i in range(nvar)} for i in range(nvar): if hasattr(ecu_list[i], "subs"): ecu_list[i] = ecu_list[i].subs(a_subs).subs(v_subs).subs(x_subs) a_list = sorted(list(a_subs.values()), key = str) return solveswc(ecu_list, a_list)
def _derive_dw_dpsi(): """Derive the slope dw_dpsi with sympy Returns ------- dw_dpsi1 : sympy expression Derivative including correction factor. dw_dpsi2 : sympy expression Derivative with correction factor equal to one. """ psi, a, n, m, psir, ws = sympy.symbols('psi, a, n, m, psir, ws') psi, ws, a, b, wr, s1, psir = sympy.symbols('psi, ws, a, b, wr, s1, psir') from sympy import log, exp C1 = (1 - log(1 + psi / psir) / log(1.0 + 1.0e6 / psir)) C2 = 1 l10 = sympy.symbols('l10') w = C1 * ((ws - s1 * log(psi)/l10 - wr) * a / (psi**b + a) + wr) dw_dpsi1 = sympy.diff(w, psi) w = C2 * ((ws - s1 * log(psi)/l10 - wr) * a / (psi**b + a) + wr) dw_dpsi2 = sympy.diff(w, psi) return dw_dpsi1, dw_dpsi2
def test_legendre(): raises(ValueError, lambda: legendre(-1, x)) assert legendre(0, x) == 1 assert legendre(1, x) == x assert legendre(2, x) == ((3*x**2 - 1)/2).expand() assert legendre(3, x) == ((5*x**3 - 3*x)/2).expand() assert legendre(4, x) == ((35*x**4 - 30*x**2 + 3)/8).expand() assert legendre(5, x) == ((63*x**5 - 70*x**3 + 15*x)/8).expand() assert legendre(6, x) == ((231*x**6 - 315*x**4 + 105*x**2 - 5)/16).expand() assert legendre(10, -1) == 1 assert legendre(11, -1) == -1 assert legendre(10, 1) == 1 assert legendre(11, 1) == 1 assert legendre(10, 0) != 0 assert legendre(11, 0) == 0 assert roots(legendre(4, x), x) == { sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1, -sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1, sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1, -sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1, } n = Symbol("n") X = legendre(n, x) assert isinstance(X, legendre) assert legendre(-n, x) == legendre(n - 1, x) assert legendre(n, -x) == (-1)**n*legendre(n, x) assert diff(legendre(n, x), x) == \ n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1) assert diff(legendre(n, x), n) == Derivative(legendre(n, x), n)
def hamiltonian(Lagrangian, t = Symbol('t'), delta = False): """ Returns the Hamiltonian of the Lagrangian. Examples ======== >>> from sympy import * >>> t, k = symbols('t k') >>> x = symbols('x', cls=Function) >>> hamiltonian(diff(x(t),t)**2/2 - k*x(t)**2/2) k*x**2/2 + v_x**2/2 """ Lagrangian = simplify(Lagrangian) var_list = [list(x.atoms(Function))[0] for x in Lagrangian.atoms(Derivative)] nvar = len(var_list) # New variables. str_list = [ str(variable).replace("("+str(t)+")","") for variable in var_list ] v_subs = {diff(var_list[i],t): Symbol('v_' + str_list[i]) for i in range(nvar)} x_subs = {var_list[i]: Symbol(str_list[i]) for i in range(nvar)} # Hamiltonian calculus. dxdLv = 0 for variable in var_list: dxdLv += diff(variable,t)*diff(Lagrangian, diff(variable,t)) result = simplify((dxdLv - Lagrangian).subs(v_subs).subs(x_subs)) if delta: v0_subs = {Symbol('v_' + str_list[i]): Symbol('v_' + str_list[i] + "0") for i in range(nvar)} x0_subs = {Symbol(str_list[i]): Symbol(str_list[i] + "0") for i in range(nvar)} return result - result.subs(v0_subs).subs(x0_subs) else: return result
def ItoFormula_2(function,a,b,dt): func = compile(function,"",'eval') a=float(a) b=float(b) n=int((b-a)/dt) WP = 0 t = a for i in range(int(a/dt)): WP = WP+np.random.normal(0,math.sqrt(dt)) part_1 = eval(func) f = sym.sympify(function) WP = sym.Symbol('WP') df = str(sym.diff(f,WP)) ddf = str(sym.diff(df,WP)) part_2 = 0 part_3 = 0 result_2 = 0 WP = 0 for i in range(0,n): t=dt*((a/dt)+i) WP = WP+np.random.normal(0,math.sqrt(dt)) k2 = eval(df,valueDic) k3 = eval(ddf,valueDic) part_2 = part_2 + k2*(WT[i+1]-WT[i]) part_3 = part_3 + k3*dt result_2 = part_1 + part_2 + part_3 print 'ito formula result: '+str(result_2)
def make_qdiff_to_q012(x_names): qdiff_to_q012 = {} qdiff_0 = {} qdiff_1 = {} qdiff_2 = {} for date_str in ['tp1', 't', 'tm1']: dated_names = [name + date_str for name in x_names] dated_q_fun_sym = [sympy.Function(x)(q) for x in dated_names] dated_names_0 = [name + '_0' for name in dated_names] dated_names_0_sym = [sympy.Symbol(x) for x in dated_names_0] qdiff_0.update(dict(zip(dated_q_fun_sym, dated_names_0_sym))) dated_qdiffs_1 = [sympy.diff(x, q, 1) for x in dated_q_fun_sym] dated_names_1 = [name + '_1' for name in dated_names] dated_names_1_sym = [sympy.Symbol(x) for x in dated_names_1] qdiff_1.update(dict(zip(dated_qdiffs_1, dated_names_1_sym))) dated_qdiffs_2 = [sympy.diff(x, q, 2) for x in dated_q_fun_sym] dated_names_2 = [name + '_2' for name in dated_names] dated_names_2_sym = [sympy.Symbol(x) for x in dated_names_2] qdiff_2.update(dict(zip(dated_qdiffs_2, dated_names_2_sym))) qdiff_to_q012.update(qdiff_0) qdiff_to_q012.update(qdiff_1) qdiff_to_q012.update(qdiff_2) return qdiff_to_q012
def update_integral_data(u_str, v_str, cx_str, cy_str): #string parsing u_fun, _ = my_bokeh_utils.string_to_function_parser(u_str, ['x', 'y']) v_fun, _ = my_bokeh_utils.string_to_function_parser(v_str, ['x', 'y']) cx_fun, cx_sym = my_bokeh_utils.string_to_function_parser(cx_str, ['t']) cy_fun, cy_sym = my_bokeh_utils.string_to_function_parser(cy_str, ['t']) from sympy import diff dcx_sym = diff(cx_sym,'t') dcy_sym = diff(cy_sym,'t') dcx_fun = my_bokeh_utils.sym_to_function_parser(dcx_sym, 't') dcy_fun = my_bokeh_utils.sym_to_function_parser(dcy_sym, 't') t = np.linspace(curveintegral_settings.parameter_min,curveintegral_settings.parameter_max) f_I = lambda xx, tt: (u_fun(cx_fun(tt),cy_fun(tt)) * dcx_fun(tt) + v_fun(cx_fun(tt),cy_fun(tt)) * dcy_fun(tt)) integrand = f_I(None,t) from scipy.integrate import odeint integral = odeint(f_I,0,t) source_integral.data = dict(t=t.tolist(), integral=integral.tolist(), integrand=integrand.tolist())
p11, p12, p13, p14, \ p22, p23, p24, \ p33, p34, \ p44 \ = symbols('p11 p12 p13 p14 \ p22 p23 p24 \ p33 p34 \ p44') P = Matrix([[p11, p12, p13, p14], [p12, p22, p23, p24], [p13, p23, p33, p34], [p14, p24, p34, p44]]) F = Matrix([[diff(h_dot, h), diff(theta_dot, h), diff(v_dot, h), diff(gam_dot, h)], [diff(h_dot, theta), diff(theta_dot, theta), diff(v_dot, theta), diff(gam_dot, theta)], [diff(h_dot, v), diff(theta_dot, v), diff(v_dot, v), diff(gam_dot, v)], [diff(h_dot, gam), diff(theta_dot, gam), diff(v_dot, gam), diff(gam_dot, gam)]]).T G = Matrix([[0, 0], [0, 0], [1, 0], [0, 1]]) theta_r = theta - theta_b Rho = sqrt( r_e ** 2 + r ** 2 - 2 * r * r_e * cos(theta - theta_b)) # sqrt(2*r_e*(r_e + h)*(1 - cos(theta_r)) + h**2) H = Matrix([[diff(Rho, h), diff(Rho, theta), diff(Rho, v), diff(Rho, gam)]])
def test_heurisch_symbolic_coeffs(): assert heurisch(1 / (x + y), x) == log(x + y) assert heurisch(1 / (x + sqrt(2)), x) == log(x + sqrt(2)) assert simplify(diff(heurisch(log(x + y + z), y), y)) == log(x + y + z)
def test_BVirial_Pitzer_Curl_calculus(): from sympy import symbols, Rational, diff, lambdify, integrate # Derivatives check # Uses SymPy T, Tc, Pc, omega, R = symbols('T, Tc, Pc, omega, R') Tr = T/Tc B0 = Rational(1445,10000) - Rational(33,100)/Tr - Rational(1385,10000)/Tr**2 - Rational(121,10000)/Tr**3 B1 = Rational(73,1000) + Rational(46,100)/Tr - Rational(1,2)/Tr**2 - Rational(97,1000)/Tr**3 - Rational(73,10000)/Tr**8 # Note: scipy.misc.derivative was attempted, but found to given too # incorrect of derivatives for higher orders, so there is no reasons to # implement it. Plus, no uses have yet been found for the higher # derivatives/integrals. For integrals, there is no way to get the # indefinite integral. # Test 160K points in vector form for order 1, 2, and 3 # Use lambdify for fast evaluation _Ts = np.linspace(5,500,20) _Tcs = np.linspace(501,900,20) _Pcs = np.linspace(2E5, 1E7,20) _omegas = np.linspace(-1, 10,20) _Ts, _Tcs, _Pcs, _omegas = np.meshgrid(_Ts, _Tcs, _Pcs, _omegas) _Ts, _Tcs, _Pcs, _omegas = _Ts.ravel(), _Tcs.ravel(), _Pcs.ravel(), _omegas.ravel() for order in range(1,4): B0c = diff(B0, T, order) B1c = diff(B1, T, order) Br = B0c + omega*B1c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = BVirial_Pitzer_Curl(_Ts, _Tcs, _Pcs, _omegas, order) assert_allclose(Bcalcs, Bcalc2) # Check integrals using SymPy: for order in range(-2, 0): B0c = B0 B1c = B1 for i in range(abs(order)): B0c = integrate(B0c, T) B1c = integrate(B1c, T) Br = B0c + omega*B1c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = [BVirial_Pitzer_Curl(T2, Tc2, Pc2, omega2, order) for T2, Tc2, Pc2, omega2 in zip(_Ts, _Tcs, _Pcs, _omegas)] assert_allclose(Bcalcs, Bcalc2) # Check integrals using numerical methods - quad: for order in range(-2, 0): for trial in range(10): T1, T2 = np.random.random_integers(5, 500, 2)*np.random.rand(2) _Tc = np.random.choice(_Tcs) _Pc = np.random.choice(_Pcs) _omega = np.random.choice(_omegas) dBint = BVirial_Pitzer_Curl(T2, _Tc, _Pc, _omega, order) - BVirial_Pitzer_Curl(T1, _Tc, _Pc, _omega, order) dBquad = quad(BVirial_Pitzer_Curl, T1, T2, args=(_Tc, _Pc, _omega, order+1))[0] assert_allclose(dBint, dBquad, rtol=1E-5)
def test_BVirial_Tsonopoulos_extended(): from sympy import symbols, Rational, diff, lambdify, integrate B = BVirial_Tsonopoulos_extended(510., 425.2, 38E5, 0.193, species_type='normal', dipole=0) assert_allclose(B, -0.00020935288308483694) B = BVirial_Tsonopoulos_extended(430., 405.65, 11.28E6, 0.252608, a=0, b=0, species_type='ketone', dipole=1.469) assert_allclose(B, -9.679715056695323e-05) with pytest.raises(Exception): BVirial_Tsonopoulos_extended(510., 425.2, 38E5, 0.193, order=-3) # Test all of the different types types = ['simple', 'normal', 'methyl alcohol', 'water', 'ketone', 'aldehyde', 'alkyl nitrile', 'ether', 'carboxylic acid', 'ester', 'carboxylic acid', 'ester', 'alkyl halide', 'mercaptan', 'sulfide', 'disulfide', 'alkanol'] Bs_calc = [BVirial_Tsonopoulos_extended(430., 405.65, 11.28E6, 0.252608, a=0, b=0, species_type=i, dipole=0.1) for i in types] Bs = [-9.002529440027288e-05, -9.002529440027288e-05, -8.136805574379563e-05, -9.232250634010228e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.00558069055045e-05, -9.003495446399036e-05, -9.003495446399036e-05, -9.003495446399036e-05, -9.003495446399036e-05, -7.331247111785242e-05] assert_allclose(Bs_calc, Bs) # Use lambdify for fast evaluation _Ts = np.linspace(5,500,20) _Tcs = np.linspace(501,900,20) _Pcs = np.linspace(2E5, 1E7,20) _omegas = np.linspace(-1, 10,20) _Ts, _Tcs, _Pcs, _omegas = np.meshgrid(_Ts, _Tcs, _Pcs, _omegas) _Ts, _Tcs, _Pcs, _omegas = _Ts.ravel(), _Tcs.ravel(), _Pcs.ravel(), _omegas.ravel() T, Tc, Pc, omega, R = symbols('T, Tc, Pc, omega, R') Tr = T/Tc B0 = Rational(1445, 10000) - Rational(33,100)/Tr - Rational(1385,10000)/Tr**2 - Rational(121,10000)/Tr**3 - Rational(607,1000000)/Tr**8 B1 = Rational(637,10000) + Rational(331,1000)/Tr**2 - Rational(423,1000)/Tr**3 - Rational(8,1000)/Tr**8 B2 = 1/Tr**6 B3 = -1/Tr**8 a = 0.1 b = 0.2 for order in range(1,4): B0c = diff(B0, T, order) B1c = diff(B1, T, order) B2c = diff(B2, T, order) B3c = diff(B3, T, order) Br = B0c + omega*B1c + a*B2c + b*B3c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = BVirial_Tsonopoulos_extended(_Ts, _Tcs, _Pcs, _omegas, order=order, a=a, b=b) assert_allclose(Bcalcs, Bcalc2) # Check integrals using SymPy: for order in range(-2, 0): B0c = B0 B1c = B1 B2c = B2 B3c = B3 for i in range(abs(order)): B0c = integrate(B0c, T) B1c = integrate(B1c, T) B2c = integrate(B2c, T) B3c = integrate(B3c, T) Br = B0c + omega*B1c + a*B2c + b*B3c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = [BVirial_Tsonopoulos_extended(T2, Tc2, Pc2, omega2, a=a, b=b, order=order) for T2, Tc2, Pc2, omega2 in zip(_Ts, _Tcs, _Pcs, _omegas)] assert_allclose(Bcalcs, Bcalc2) # Check integrals using numerical methods - quad: for order in range(-2, 0): for trial in range(10): T1, T2 = np.random.random_integers(5, 500, 2)*np.random.rand(2) _Tc = np.random.choice(_Tcs) _Pc = np.random.choice(_Pcs) _omega = np.random.choice(_omegas) dBint = BVirial_Tsonopoulos_extended(T2, _Tc, _Pc, _omega, a=a, b=b, order=order) - BVirial_Tsonopoulos_extended(T1, _Tc, _Pc, _omega, a=a, b=b, order=order) dBquad = quad(BVirial_Tsonopoulos_extended, T1, T2, args=(_Tc, _Pc, _omega, a, b, '', 0, order+1))[0] assert_allclose(dBint, dBquad, rtol=3E-5)
def test_BVirial_Tsonopoulos(): from sympy import symbols, Rational, diff, lambdify, integrate B = BVirial_Tsonopoulos(510., 425.2, 38E5, 0.193) assert_allclose(B, -0.00020935288308483694) with pytest.raises(Exception): BVirial_Tsonopoulos(510., 425.2, 38E5, 0.193, order=-3) T, Tc, Pc, omega, R = symbols('T, Tc, Pc, omega, R') Tr = T/Tc B0 = Rational(1445, 10000) - Rational(33,100)/Tr - Rational(1385,10000)/Tr**2 - Rational(121,10000)/Tr**3 - Rational(607,1000000)/Tr**8 B1 = Rational(637,10000) + Rational(331,1000)/Tr**2 - Rational(423,1000)/Tr**3 - Rational(8,1000)/Tr**8 # Test 160K points in vector form for order 1, 2, and 3 # Use lambdify for fast evaluation _Ts = np.linspace(5,500,20) _Tcs = np.linspace(501,900,20) _Pcs = np.linspace(2E5, 1E7,20) _omegas = np.linspace(-1, 10,20) _Ts, _Tcs, _Pcs, _omegas = np.meshgrid(_Ts, _Tcs, _Pcs, _omegas) _Ts, _Tcs, _Pcs, _omegas = _Ts.ravel(), _Tcs.ravel(), _Pcs.ravel(), _omegas.ravel() for order in range(1,4): B0c = diff(B0, T, order) B1c = diff(B1, T, order) Br = B0c + omega*B1c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = BVirial_Tsonopoulos(_Ts, _Tcs, _Pcs, _omegas, order) assert_allclose(Bcalcs, Bcalc2) # Check integrals using SymPy: for order in range(-2, 0): B0c = B0 B1c = B1 for i in range(abs(order)): B0c = integrate(B0c, T) B1c = integrate(B1c, T) Br = B0c + omega*B1c BVirial = (Br*R*Tc/Pc).subs(R, _R) f = lambdify((T, Tc, Pc, omega), BVirial, "numpy") Bcalcs = f(_Ts, _Tcs, _Pcs, _omegas) Bcalc2 = [BVirial_Tsonopoulos(T2, Tc2, Pc2, omega2, order) for T2, Tc2, Pc2, omega2 in zip(_Ts, _Tcs, _Pcs, _omegas)] assert_allclose(Bcalcs, Bcalc2) # Check integrals using numerical methods - quad: for order in range(-2, 0): for trial in range(10): T1, T2 = np.random.random_integers(5, 500, 2)*np.random.rand(2) _Tc = np.random.choice(_Tcs) _Pc = np.random.choice(_Pcs) _omega = np.random.choice(_omegas) dBint = BVirial_Tsonopoulos(T2, _Tc, _Pc, _omega, order) - BVirial_Tsonopoulos(T1, _Tc, _Pc, _omega, order) dBquad = quad(BVirial_Tsonopoulos, T1, T2, args=(_Tc, _Pc, _omega, order+1))[0] assert_allclose(dBint, dBquad, rtol=1E-5)
def derivative(self, diff): derivative = sympy.diff(self.expression, diff.symbol) result = SymDim(expression=derivative) result.evaluate() return result
p1 = sym.Symbol('p1') p2 = sym.Symbol('p2') p3 = sym.Symbol('p3') p4 = sym.Symbol('p4') q1 = sym.Symbol('q1') q2 = sym.Symbol('q2') q3 = sym.Symbol('q3') q4 = sym.Symbol('q4') R = sym.Symbol('R', constant=True) S = sym.Symbol('S', constant=True) T = sym.Symbol('T', constant=True) P = sym.Symbol('P', constant=True) D_SY = sym.Matrix( \ [ [p1*q1-1, p1-1, q1-1, R], \ [p2*q3, p2-1, q3, T], \ [p3*q2, p3, q2-1, S], \ [p4*q4, p4, q4, P] ]) D_1 = sym.Matrix( \ [ [p1*q1-1, p1-1, q1-1, 1], \ [p2*q3, p2-1, q3, 1], \ [p3*q2, p3, q2-1, 1], \ [p4*q4, p4, q4, 1] ]) up = sym.det(D_SY) down = sym.det(D_1) diff_up = sym.simplify(sym.diff(up, p1) * down - up * sym.diff(down, p1)) print(sym.simplify(sym.diff(diff_up, p1)))
v_dot = g * sin(theta) writeList = [x_dot, y_dot, v_dot] # Covariance Calculations p11, p12, p13, \ p22, p23, \ p33 \ = symbols('p11 p12 p13\ p22 p23 \ p33' ) P = Matrix([[p11, p12, p13], [p12, p22, p23], [p13, p23, p33]]) F = Matrix([[diff(x_dot, x), diff(x_dot, y), diff(x_dot, v)], [diff(y_dot, x), diff(y_dot, y), diff(y_dot, v)], [diff(v_dot, x), diff(v_dot, y), diff(v_dot, v)]]) G = Matrix([[0], [0], [1]]) h = v**2 H = Matrix([[diff(h, x), diff(h, y), diff(h, v)]])
x0, y0, x1, y1, x2, y2, x3, y3 = symbols('x0 y0 x1 y1 x2 y2 x3 y3') points = [(2, 3), (4, 4), (3, 2.5), (4.5, 5) ] def f(x0, y0, x1, y1, x2, y2, x3, y3): _sum = 0 for t, (x, y) in enumerate(points): _sum += distance(bezier(x0, x1, x2, x3, t), (x, y)) dx0 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), x0)).coeffs() dy0 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), y0)).coeffs() dx1 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), x1)).coeffs() dy1 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), y1)).coeffs() dx2 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), x2)).coeffs() dy2 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), y2)).coeffs() dx3 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), x3)).coeffs() dy3 = Poly(diff(f(x0, y0, x1, y1, x2, y2, x3, y3), y3)).coeffs() A = np.array([dx0[:-1], dy0[:-1], dx1[:-1], dy1[:-1], dx2[:-1], dy2[:-1], dx3[:-1], dy3[:-1]], dtype=float) X = np.linalg.solve(A, B).flatten() print(f'y^ = {round(X[1], 3)}x + {round(X[0], 3)}')
= symbols('p11 p12 p13 p14 p15 p16 \ p22 p23 p24 p25 p26 \ p33 p34 p35 p36 \ p44 p45 p46 \ p55 p56 \ p66' ) P = Matrix([[p11, p12, p13, p14, p15, p16], [p12, p22, p23, p24, p25, p26], [p13, p23, p33, p34, p35, p36], [p14, p24, p34, p44, p45, p46], [p15, p25, p35, p45, p55, p56], [p16, p26, p36, p46, p56, p66]]) F = Matrix([[ diff(x1_dot, x1), diff(x1_dot, y1), diff(x1_dot, theta1), diff(x1_dot, x2), diff(x1_dot, y2), diff(x1_dot, theta2) ], [ diff(y1_dot, x1), diff(y1_dot, y1), diff(y1_dot, theta1), diff(y1_dot, x2), diff(y1_dot, y2), diff(y1_dot, theta2) ], [
def differentiate(expr, wrt=None, wrt_list=None): """Return derivative of expression. This function returns an expression or list of expression objects corresponding to the derivative of the passed expression 'expr' with respect to a variable 'wrt' or list of variables 'wrt_list' Args: expr (Expression): Pyomo expression wrt (Var): Pyomo variable wrt_list (list): list of Pyomo variables Returns: Expression or list of Expression objects """ if not sympy_available: raise RuntimeError( "The sympy module is not available.\n\t" "Cannot perform automatic symbolic differentiation.") if not ((wrt is None) ^ (wrt_list is None)): raise ValueError( "differentiate(): Must specify exactly one of wrt and wrt_list") import sympy # # Convert the Pyomo expression to a sympy expression # objectMap, sympy_expr = sympyify_expression(expr) # # The partial_derivs dict holds intermediate sympy expressions that # we can re-use. We will prepopulate it with None for all vars that # appear in the expression (so that we can detect wrt combinations # that are, by definition, 0) # partial_derivs = dict((x, None) for x in objectMap.sympyVars()) # # Setup the WRT list # if wrt is not None: wrt_list = [wrt] else: # Copy the list because we will normalize things in place below wrt_list = list(wrt_list) # # Convert WRT vars into sympy vars # ans = [None] * len(wrt_list) for i, target in enumerate(wrt_list): if target.__class__ is not tuple: target = (target, ) wrt_list[i] = tuple(objectMap.getSympySymbol(x) for x in target) for x in wrt_list[i]: if x not in partial_derivs: ans[i] = 0. break # # We assume that users will not request duplicate derivatives. We # will only cache up to the next-to last partial, and if a user # requests the exact same derivative twice, then we will just # re-calculate it. # last_partial_idx = max(len(x) for x in wrt_list) - 1 # # Calculate all the derivatives # for i, target in enumerate(wrt_list): if ans[i] is not None: continue part = sympy_expr for j, wrt_var in enumerate(target): if j == last_partial_idx: part = sympy.diff(part, wrt_var) else: partial_target = target[:j + 1] if partial_target in partial_derivs: part = partial_derivs[partial_target] else: part = sympy.diff(part, wrt_var) partial_derivs[partial_target] = part ans[i] = sympy2pyomo_expression(part, objectMap) # # Return the answer # return ans if wrt is None else ans[0]
pF = normal(s, g(mux), Sigma_s) \ * normal(dmux, f(mux, munu), Sigma_x)\ * normal(dmunu, munu, Sigma_nu) # %% F = -log(pF[0]) - C F = F.expand(force=True) F = F.collect(Sigma_s) F = F.collect(Sigma_x) F = F.collect(Sigma_nu) display(F) # %% d_mux = Eq(-diff("F", mux, evaluate=False), -syp.separatevars(diff(F, mux), force=True), evaluate=False) display(d_mux) print(syp.latex(d_mux)) # %% d_dmux = Eq(-diff("F", dmux, evaluate=False), -diff(F, dmux).simplify(), evaluate=False) display(d_dmux) print(syp.latex(d_dmux)) # %% a = symbols("a", real=True) spa = syp.Function("s_p")(a)
import sympy as sp x = sp.Symbol('x') y = x**10 + 2 * (x - 10)**9 for n in range(1, 12): y = d = sp.diff(y) print('第%2d阶导数为:%s' % (n, d))
def find_inflections(path, file, study, format_type, record, sensor, segment, range): """ """ source = os.path.join('studies', study, 'formatted', format_type, record, segment, sensor + '.csv') print('source = ' + source) df = pd.read_csv(source) print('df = ') print(df) for colName in df.columns: # remove extra columns because the dataframe will be saved if 'Unnamed' in str(colName): del df[colName] # save the timestamps as a list elif 'Minutes' in str(colName): timeMinutes = list(df[colName]) elif 'meas' in colName: # add new columns to the dataframe to save the new variables newColNames = [ 'inflectionDecision', 'inflectionLocation', 'polyfitCoefficients', 'polyfitEquation', 'polyfitSolution', 'derivativeEquation', 'derivativeSolution' ] colNameSplit = colName.split('_') print('colNameSplit[0] = ' + colNameSplit[0]) for suffix in newColNames: label = str(colNameSplit[0] + '_' + suffix) print('label = ' + label) if label not in df.columns: df[label] = [None] * len((list(df['timeMinutes']))) df['timeBegin'] = [None] * len((list(df['timeMinutes']))) df['timeEnd'] = [None] * len((list(df['timeMinutes']))) for timeMinute in timeMinutes: i = df[df['timeMinutes'] == timeMinute].index.values[0] timeDif = (float(df.loc[2, 'timeMinutes']) - float(df.loc[1, 'timeMinutes'])) timeTolerance = timeDif / 2 iRange = int(range / 60 * 1 / (timeDif)) # print('iRange = ' + str(iRange)) if len(list(df['timeMinutes'])) - i <= iRange + 2: continue timeMedian = df.loc[int(i + iRange / 2), 'timeMinutes'] timeBegin = df.loc[int(i), 'timeMinutes'] timeEnd = df.loc[int(i + iRange), 'timeMinutes'] # print('timeMedian = ' + str(timeMedian) + ' timeBegin = ' + str(timeBegin) + ' timeEnd = ' + str(timeEnd)) # print('range = ' + str(range/60) + ' timeEnd-timeBegin = ' + str(timeEnd-timeBegin) + ' % = ' + str(range/60/(timeEnd-timeBegin))) df_truncate = df[df['timeMinutes'] >= timeMinute] df_truncate = df_truncate[ df_truncate['timeMinutes'] <= timeMinute + range / 60] # df_truncate = df[df['timeMinutes'] >= timeMinute & df_truncate['timeMinutes'] <= timeMinute + range/60] timeTruncate = list(df_truncate['timeMinutes']) df.loc[int(i + iRange / 2), 'timeBegin'] = min(timeTruncate) df.loc[int(i + iRange / 2), 'timeEnd'] = max(timeTruncate) measTruncate = list(df_truncate[colName]) coef = np.polyfit(timeTruncate, measTruncate, 2) x = sym.Symbol('x') f = coef[0] * x * x + coef[1] * x + coef[2] dff = sym.diff(f, x) solf = sym.solve(f) soldf = sym.solve(dff) soldf = soldf[0] label = str(colNameSplit[0] + '_' + 'inflectionDecision') df.loc[int(i + iRange / 2), label] = 'No' label = str(colNameSplit[0] + '_' + 'inflectionLocation') df.loc[int(i + iRange / 2), label] = timeMinute label = str(colNameSplit[0] + '_' + 'polyfitCoefficients') df.loc[int(i + iRange / 2), label] = str(''.join([str(x) for x in coef])) label = str(colNameSplit[0] + '_' + 'polyfitEquation') df.loc[int(i + iRange / 2), label] = str(f) label = str(colNameSplit[0] + '_' + 'polyfitSolution') df.loc[int(i + iRange / 2), label] = str(''.join([str(x) for x in solf])) label = str(colNameSplit[0] + '_' + 'derivativeEquation') df.loc[int(i + iRange / 2), label] = str(dff) label = str(colNameSplit[0] + '_' + 'derivativeSolution') df.loc[int(i + iRange / 2), label] = str(soldf) if soldf < timeMedian + timeTolerance: if soldf > timeMedian - timeTolerance: print('inflection found at time = ' + str(soldf)) label = str(colNameSplit[0] + '_' + 'inflectionDecision') df.loc[int(i + iRange / 2), label] = 'Yes' path = build_path(path) file = os.path.join(path, sensor + ".csv") df.to_csv(file) print('inflection list saved : ' + file) return (file)
#!/usr/bin/env python # -*- coding: utf-8 -*- import numpy as np import sympy as sym from functools import partial x = sym.symbols('x0 x1') F0 = sym.tan(x[0] * x[1] + 0.5) - x[0]**2 F1 = x[0]**2 + x[1]**2 - 1 J1 = sym.lambdify(x, sym.diff(F0, x[0])) J2 = sym.lambdify(x, sym.diff(F0, x[1])) J3 = sym.lambdify(x, sym.diff(F1, x[0])) J4 = sym.lambdify(x, sym.diff(F1, x[1])) def newton_method(f, J, x, eps): f_value = f(x) f_norm = np.linalg.norm(f_value, ord=2) while abs(f_norm) > eps: delta = np.linalg.solve(J(x), -f_value) x += delta f_value = f(x) f_norm = np.linalg.norm(f_value, ord=2) return x def newton_method_mod(f, J, x, eps): f_value = f(x) f_norm = np.linalg.norm(f_value, ord=2) jacobian = J(x)
print ("") sympy.pprint(res) time.sleep(delay) cls() else: print("Я не знаю, что вы ввели, попробуйте ещё раз") ############################################################################################################################## # Высшая математика elif (value == 5): value = int(input("\n 15) Производная \n 25) Интеграл \n 35) Лимит (x->оо) \n 45) Лимит (x->0) \n 55) Лимит (x->1) \n 65) Лимит (любое число) \n 75) Определённый интеграл \n \n ")) # Производная if (value == 15): print ("") input_string = raw_input(' Выражение: ') print ("") res = sum(sympy.diff(input_string, var) for var in [x, y]) sympy.pprint(res) time.sleep(delay) cls() # Интеграл elif (value == 25): print ("") x = Symbol("x") y = Symbol("y") input_string = input(' Выражение: ') print ("") sympy.pprint(sympy.Integral(input_string, x)) print ("") sympy.pprint(integrate(input_string, x)) time.sleep(delay) cls()
cur_obs_lat = obs_lat_vector[i_obs][0, 0] cur_obs_lon = obs_lon_vector[i_obs][0, 0] cur_obs_operator_input = {} for required_bk_var in required_bk_vars: start_index = background_type_vector.tolist().index( [str(required_bk_var)]) cur_obs_operator_input[str( required_bk_var)] = background_data_vector[start_index + n][0, 0] cur_distance0 = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2) distance_conversion0 = cur_distance0 / float( total_distance) linearized_observation_operator[ i_obs, start_index + n] = sympy.diff( direct_obs_operator[cur_obs_type], background_type_vector[start_index + n][0, 0]) bkg_weight_0 = 0 bkg_weight_1 = 0 for ii in range(0, bkg_shape[0]): for jj in range(0, bkg_shape[1]): cur_bk_lat = background_data_dict['lat'][ii, jj] cur_bk_lon = background_data_dict['lon'][ii, jj] cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2) cur_distance_weight_0 = ( direct_obs_operator[cur_obs_type].subs( cur_obs_operator_input)) / float(cur_distance** 2)
fnlfid = values['fnlfid'] shot = 1./dic['ngal']+0.*Pgg #### Define symbols b, fnl, nbar, Pnl, func = sp.symbols('b fnl nbar Pnl func') bias = b+fnl*func P_total = bias**2.+1/nbar print(P_total) print(sp.diff(P_total, b)) derb_P_s = sp.diff(P_total, b) derb_P = sp.lambdify([b, fnl, nbar, Pnl, func], derb_P_s, 'numpy') result = derb_P(1., 0., 1., Pnn*0.+1., Pgn*0.+1.) print(result) ''' fig, ax = plt.subplots( nrows=1, ncols=1 ) #plt.xlim(0.01, 0.1) #plt.ylim(1e1, 1e8) plt.xlabel('$K$ $(h Mpc^{-1})$') plt.ylabel('$P$ $(h^{-3} Mpc^{3})$') ax.plot(K, Pgg, label = 'Pgg for fnl='+str(fnlfid)) ax.plot(K, Pnn, label = 'Pnn, n = growth est')
# July 2020 # OBJECCTIVE: 1. Sympy: SymPy is a Python library for symbolic mathematics (Linear algebra). It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python. import numpy as np import matplotlib.pyplot as plt import sympy as sym from sympy import init_session my_teaser_array = np.array([1, 7, 19, 37, 61, 91, 127, 169, 217, 271, 331]) # 1. Diff in numpy: Substracts the elements print('Onee time: ',np.diff(my_teaser_array)) print('Two times',np.diff(my_teaser_array,2)) print('Three times',np.diff(my_teaser_array,3)) # 2. DIFF in sympy from sympy import init_session # init_session() # Create interactive platform x=sym.Symbol('x') print(sym.diff(x**3)) print(sym.diff(x**3,x,3))
ax.plot_surface(x_4, y_4, f(x_4, y_4), cmap=cm.coolwarm, alpha=0.4) plt.show() # # Partial Derivatives & Symbolic Computation # # $$\frac{\partial f}{\partial x} = \frac{2x \ln(3) \cdot 3^{-x^2 - y^2}}{\left( 3^{-x^2 - y^2} + 1 \right) ^2}$$ # # # $$\frac{\partial f}{\partial y} = \frac{2y \ln(3) \cdot 3^{-x^2 - y^2}}{\left( 3^{-x^2 - y^2} + 1 \right) ^2}$$ # In[27]: a, b = symbols('x,y') print('Our cost function f(x,y) is:', f(a, b)) print('partial derivatives wrt x is:', diff(f(a, b), a)) print('Value of f(x,y) at x =1.8 y=1;0 ', f(a, b).evalf(subs={a: 1.8, b: 1.0})) print('', diff(f(a, b), a).evalf(subs={a: 1.8, b: 1.0})) # In[ ]: # # Batch Gradiet Descent with SymPy # In[28]: # setup multiplier = 0.1 max_iter = 500 params = np.array([1.8, 1.0]) # intial guess
def apply_constraints(self, f, vars, evaluation): "Minimize[f_List, vars_List]" head_name = vars.get_head_name() vars_or = vars vars = vars.leaves for var in vars: if ((var.is_atom() and not var.is_symbol()) or head_name in ( "System`Plus", "System`Times", "System`Power") # noqa or "System`Constant" in var.get_attributes( evaluation.definitions)): evaluation.message("Minimize", "ivar", vars_or) return vars_sympy = [var.to_sympy() for var in vars] constraints = [function for function in f.leaves] objective_function = constraints[0].to_sympy() constraints = constraints[1:] g_functions = [] h_functions = [] g_variables = [] h_variables = [] for constraint in constraints: left, right = constraint.leaves head_name = constraint.get_head_name() left = left.to_sympy() right = right.to_sympy() if head_name == "System`LessEqual" or head_name == "System`Less": eq = left - right eq = sympy.together(eq) eq = sympy.cancel(eq) g_functions.append(eq) g_variables.append( sympy.Symbol("kkt_g" + str(len(g_variables)))) elif head_name == "System`GreaterEqual" or head_name == "System`Greater": eq = -1 * (left - right) eq = sympy.together(eq) eq = sympy.cancel(eq) g_functions.append(eq) g_variables.append( sympy.Symbol("kkt_g" + str(len(g_variables)))) elif head_name == "System`Equal": eq = left - right eq = sympy.together(eq) eq = sympy.cancel(eq) h_functions.append(eq) h_variables.append( sympy.Symbol("kkt_h" + str(len(h_variables)))) equations = [] for variable in vars_sympy: equation = sympy.diff(objective_function, variable) for i in range(len(g_variables)): g_variable = g_variables[i] g_function = g_functions[i] equation = equation + g_variable * sympy.diff( g_function, variable) for i in range(len(h_variables)): h_variable = h_variables[i] h_function = h_functions[i] equation = equation + h_variable * sympy.diff( h_function, variable) equations.append(equation) for i in range(len(g_variables)): g_variable = g_variables[i] g_function = g_functions[i] equations.append(g_variable * g_function) for i in range(len(h_variables)): h_variable = h_variables[i] h_function = h_functions[i] equations.append(h_variable * h_function) all_variables = vars_sympy + g_variables + h_variables candidates_tmp = sympy.solve(equations, all_variables, dict=True) candidates = [] for candidate in candidates_tmp: if len(candidate) != len(vars_sympy): for variable in candidate: for i in range(len(candidate), len(vars_sympy)): candidate[variable] = candidate[variable].subs( {vars_sympy[i]: 1}) for i in range(len(candidate), len(vars_sympy)): candidate[vars_sympy[i]] = 1 candidates.append(candidate) kkt_candidates = [] for candidate in candidates: kkt_ok = True sum_constraints = 0 for i in range(len(g_variables)): g_variable = g_variables[i] g_function = g_functions[i] if candidate[g_variable] < 0: kkt_ok = False if candidate[g_variable] * g_function.subs(candidate) != 0: kkt_ok = False sum_constraints = sum_constraints + candidate[g_variable] for i in range(len(h_variables)): h_variable = h_variables[i] h_function = h_functions[i] sum_constraints = sum_constraints + abs(candidate[h_variable]) if sum_constraints <= 0: kkt_ok = False if not kkt_ok: continue kkt_candidates.append(candidate) hessian = sympy.Matrix([[sympy.diff(deriv, x) for x in all_variables] for deriv in equations]) for i in range(0, len(all_variables) - len(vars_sympy)): hessian.col_del(len(all_variables) - i - 1) hessian.row_del(len(all_variables) - i - 1) minimum_list = [] for candidate in kkt_candidates: eigenvals = hessian.subs(candidate).eigenvals() positives_eigenvalues = 0 negatives_eigenvalues = 0 for val in eigenvals: val = complex(sympy.N(val, chop=True)) if val.imag == 0: val = val.real if val < 0: negatives_eigenvalues += 1 elif val > 0: positives_eigenvalues += 1 if positives_eigenvalues + negatives_eigenvalues != len(eigenvals): continue if positives_eigenvalues == len(eigenvals): for g_variable in g_variables: del candidate[g_variable] for h_variable in h_variables: del candidate[h_variable] minimum_list.append(candidate) return Expression( "List", *(Expression( "List", from_sympy(objective_function.subs(minimum).simplify()), [ Expression( "Rule", from_sympy(list(minimum.keys())[i]), from_sympy(list(minimum.values())[i]), ) for i in range(len(vars_sympy)) ], ) for minimum in minimum_list))
def test_Quantity_derivative(): x = symbols("x") assert diff(x * meter, x) == meter assert diff(x**3 * meter**2, x) == 3 * x**2 * meter**2 assert diff(meter, meter) == 1 assert diff(meter**2, meter) == 2 * meter
def calc_Dxi_x_matrix(x, i): return sympy.Matrix(2, 2, lambda r, c: sympy.diff(x.matrix()[r, c], x[i]))
def apply_multiplevariable(self, f, vars, evaluation): "Minimize[f_?NotListQ, vars_List]" head_name = vars.get_head_name() vars_or = vars vars = vars.leaves for var in vars: if ((var.is_atom() and not var.is_symbol()) or head_name in ( "System`Plus", "System`Times", "System`Power") # noqa or "System`Constant" in var.get_attributes( evaluation.definitions)): evaluation.message("Minimize", "ivar", vars_or) return vars_sympy = [var.to_sympy() for var in vars] sympy_f = f.to_sympy() jacobian = [sympy.diff(sympy_f, x) for x in vars_sympy] hessian = sympy.Matrix([[sympy.diff(deriv, x) for x in vars_sympy] for deriv in jacobian]) candidates_tmp = sympy.solve(jacobian, vars_sympy, dict=True) candidates = [] for candidate in candidates_tmp: if len(candidate) != len(vars_sympy): for variable in candidate: for i in range(len(candidate), len(vars_sympy)): candidate[variable] = candidate[variable].subs( {vars_sympy[i]: 1}) for i in range(len(candidate), len(vars_sympy)): candidate[vars_sympy[i]] = 1 candidates.append(candidate) minimum_list = [] for candidate in candidates: eigenvals = hessian.subs(candidate).eigenvals() positives_eigenvalues = 0 negatives_eigenvalues = 0 for val in eigenvals: if val.is_real: if val < 0: negatives_eigenvalues += 1 elif val >= 0: positives_eigenvalues += 1 if positives_eigenvalues + negatives_eigenvalues != len(eigenvals): continue if positives_eigenvalues == len(eigenvals): minimum_list.append(candidate) return Expression( "List", *(Expression( "List", from_sympy(sympy_f.subs(minimum).simplify()), [ Expression( "Rule", from_sympy(list(minimum.keys())[i]), from_sympy(list(minimum.values())[i]), ) for i in range(len(vars_sympy)) ], ) for minimum in minimum_list))
def calc_Dx_exp_x(x): return sympy.Matrix(2, 1, lambda r, c: sympy.diff(So2.exp(x)[r], x))
def calc_Dx_exp_x_matrix_at_0(x): return sympy.Matrix( 2, 2, lambda r, c: sympy.diff(So2.exp(x).matrix()[r, c], x)).limit(x, 0)
def calc_Dx_log_this(self): return sympy.diff(self.log(), self[0])
def calc_Dx_this_mul_exp_x_at_0(self, x): return sympy.Matrix(2, 1, lambda r, c: sympy.diff((self * So2.exp(x))[r], x))\ .limit(x, 0)
# @E-mail: [email protected] # @Site: # @Time: Jul 30, 2021 # --- from sympy import symbols, cos, sin, diff import numpy as np t, x, y, nu, pi = symbols('t x y nu pi') epsilon, eta, m = symbols('epsilon eta m') # --- ex0 --- # u = cos(pi * x) * cos(pi * y) * sin(t) h = epsilon / eta**2 * u * (u**2 - 1) u_t = diff(u, t) u_x = diff(u, x) u_y = diff(u, y) u_xx = diff(u_x, x) u_yy = diff(u_y, y) laplace_u = u_xx + u_yy laplace_x = diff(laplace_u, x) laplace_y = diff(laplace_u, y) c = -epsilon * laplace_u + h c_x = diff(c, x) c_xx = diff(c_x, x) c_y = diff(c, y) c_yy = diff(c_y, y) laplace_c = c_xx + c_yy
def calc_Dx_log_exp_x_times_this_at_0(self, x): return sympy.diff((So2.exp(x) * self).log(), x).limit(x, 0)