def order(f, a, b, n): x = sympy.symbols('x') f_ab = sympy.Subs(f, (x), (b)).n()-\ sympy.Subs(f, (x), (a)).n() df = f.diff(x) f_1n = integrate(df, a, b, n) f_2n = integrate(df, a, b, 2 * n) return math.log((f_ab - f_1n) / (f_ab - f_2n), 2)
def test_J(): """This test verifies that dJ/dt = 2*H.""" qp = phase_space_coordinates() qp_ = qp.reshape(-1).tolist() x, y, z = qp[0, :] p_x, p_y, p_z = qp[1, :] P_x_ = P_x__(*qp_) P_y_ = P_y__(*qp_) mu_ = mu__(x, y, z) r_squared_ = r_squared__(x, y) H_qp = H__(*qp_) X_H = vorpy.symplectic.symplectic_gradient_of(H_qp, qp) J_qp = J__(*qp_) # Because X_H gives the vector field defining the time derivative of a solution to the dynamics, # it follows that X_H applied to J is equal to dJ/dt (where J(t) is J(qp(t)), where qp(t) is a # solution to Hamilton's equations). X_H__J = vorpy.manifold.directional_derivative(X_H, J_qp, qp) #print(f'test_J; X_H__J = {X_H__J}') #print(f'test_J; 2*H = {sp.expand(2*H_qp)}') actual_value = X_H__J - sp.expand(2 * H_qp) #print(f'test_J; X_H__J - 2*H = {actual_value}') # Annoyingly, this doesn't simplify to 0 automatically, so some manual manipulation has to be done. # Manipulate the expression to ensure the P_x and P_y terms cancel actual_value = sp.collect(actual_value, [P_x_, P_y_]) #print(f'test_J; after collect P_x, P_y: X_H__J - 2*H = {actual_value}') actual_value = sp.Subs( actual_value, [P_x_, P_y_], [P_x_._expanded(), P_y_._expanded()]).doit() #print(f'test_J; after subs P_x, P_y: X_H__J - 2*H = {actual_value}') # Manipulate the expression to ensure the mu terms cancel actual_value = sp.factor_terms(actual_value, clear=True, fraction=True) #print(f'test_J; after factor_terms: X_H__J - 2*H = {actual_value}') actual_value = sp.collect(actual_value, [r_squared_]) #print(f'test_J; after collect r_squared_: X_H__J - 2*H = {actual_value}') actual_value = sp.Subs(actual_value, [r_squared_._expanded()], [r_squared_]).doit() #print(f'test_J; after subs r_squared: X_H__J - 2*H = {actual_value}') actual_value = sp.Subs(actual_value, [mu_._expanded()], [mu_]).doit() #print(f'test_J; after subs mu: X_H__J - 2*H = {actual_value}') if actual_value != 0: raise ValueError( f'Expected X_H__J - 2*H == 0, but actual value was {actual_value}') print('test_J passed')
def substitute_all(sp_object, pairs): """ Performs multiple substitutions in an expression :param expr: a sympy matrix or expression :param pairs: a list of pairs (a,b) where each a_i is to be substituted with b_i :return: the substituted expression """ if not isinstance(pairs, dict): dict_pairs = dict(pairs) else: dict_pairs = pairs # we recurse if the object was a matrix so we apply substitution to all elements if isinstance(sp_object, sympy.Matrix): return sp_object.applyfunc(lambda x: substitute_all(x, dict_pairs)) try: expr = sp_object.xreplace(dict_pairs) # in sympy 0.7.2, this would not work, so we do it manually except Exception: expr = sp_object for (a, b) in dict_pairs.items(): expr = sympy.Subs(expr, a, b) expr = expr.doit() return expr
def test_J_restricted_conservation(): """This test verifies that J is conserved along the flow of H if restricted to the H = 0 submanifold.""" qp = phase_space_coordinates() H_qp = H(qp) X_H = vorpy.symplectic.symplectic_gradient_of(H_qp, qp) J_qp = J(qp) X_H__J = vorpy.manifold.directional_derivative(X_H, J_qp, qp) p_z = qp[1, 2] # Solve for p_z in H_qp == 0; there are two sheets to this solution. p_z_solution_v = sp.solve(H_qp, p_z) assert len( p_z_solution_v ) == 2, f'Expected 2 solutions for p_z in H == 0, but instead got {len(p_z_solution_v)}' #print('There are {0} solutions for the equation: {1} = 0'.format(len(p_z_solution_v), H_qp)) #for i,p_z_solution in enumerate(p_z_solution_v): #print(' solution {0}: p_z = {1}'.format(i, p_z_solution)) for solution_index, p_z_solution in enumerate(p_z_solution_v): # We have to copy X_H__J or it will only be a view into X_H__J and will modify the original. # The [tuple()] access is to obtain the scalar value out of the # sympy.tensor.array.dense_ndim_array.ImmutableDenseNDimArray object that doit() returns. X_H__J__restricted = sp.Subs(np.copy(X_H__J), p_z, p_z_solution).doit()[tuple()].simplify() #print(f'solution_index = {solution_index}, X_H__J__restricted = {X_H__J__restricted}') if X_H__J__restricted != 0: raise ValueError( f'Expected X_H__J__restricted == 0 for solution_index = {solution_index}, but actual value was {X_H__J__restricted}' ) print('test_J_restricted_conservation passed')
def sim_wp(x,t): x = np.zeros(4) f = np.array([1,2,3,4], dtype=object) for i in range(4): f[i] = np.sum((p_simple_ident_zen.T*better_basis)[i]) f = sp.Subs(f, ["x1","x2","x3","x4"], [x[0], x[1], x[2], x[3]]) f= f.doit() return f
def test_conv11(): x = sympy.Symbol("x") y = sympy.Symbol("y") x1 = Symbol("x") y1 = Symbol("y") e1 = sympy.Subs(sympy.Derivative(sympy.Function("f")(x, y), x), [x, y], [y, y]) e2 = Subs(Derivative(function_symbol("f", x1, y1), [x1]), [x1, y1], [y1, y1]) e3 = Subs(Derivative(function_symbol("f", x1, y1), [x1]), [y1, x1], [x1, y1]) assert sympify(e1) == e2 assert sympify(e1) != e3 assert e2._sympy_() == e1 assert e3._sympy_() != e1
def diff_scalar_using_chain_rule(f_expr, g_expr, h_expr, ord, dNf_dgN_subs, dNg_dhN_subs): dNf_dgN_subs = dNf_dgN_subs[0:ord + 1] dNg_dhN_subs = dNg_dhN_subs[0:ord + 1] dNf_dgN_expr = sympy.Matrix.zeros(ord + 1, 1) dNf_dgN_expr[0] = f_expr dNf_dgN_expr[1] = f_expr.diff(g_expr) for i in range(2, ord + 1): dNf_dgN_expr[i] = dNf_dgN_expr[i - 1].diff(g_expr) / 2 dNg_dhN_expr = sympy.Matrix.zeros(ord + 1, 1) dNg_dhN_expr[0] = g_expr dNg_dhN_expr[1] = g_expr.diff(h_expr) for i in range(2, ord + 1): dNg_dhN_expr[i] = dNg_dhN_expr[i - 1].diff(h_expr) dNf_dhN_expr = sympy.Matrix.zeros(ord + 1, 1) dNf_dhN_expr[0] = f_expr dNf_dhN_expr[1] = f_expr.diff(h_expr) for i in range(2, ord + 1): dNf_dhN_expr[i] = dNf_dhN_expr[i - 1].diff(h_expr) f_wild_expr = sympy.Wild("p_wild", real=True) x_wild_expr = sympy.Wild("x_wild", real=True) dNf_dgN_not_yet_evaluated_expr = sympy.Matrix.zeros(ord + 1, 1) for i in range(1, ord + 1): derivative_args = [f_wild_expr] + [x_wild_expr] * i dNf_dgN_not_yet_evaluated_expr[i] = sympy.Subs( sympy.Derivative(*derivative_args), x_wild_expr, g_expr) dNf_dhN_in_terms_of_subs_expr = sympy.Matrix.zeros(ord + 1, 1) dNf_dhN_in_terms_of_subs_expr[0] = dNf_dgN_subs[0] for i in range(1, ord + 1): dNf_dhN_in_terms_of_subs_expr[i] = dNf_dhN_expr[i] dNf_dhN_in_terms_of_subs_expr[i] = dNf_dhN_in_terms_of_subs_expr[ i].subs(zip(dNg_dhN_expr[::-1], dNg_dhN_subs[::-1])[:-1], simultaneous=True) for j in range(1, ord + 1): dNf_dhN_in_terms_of_subs_expr[i] = dNf_dhN_in_terms_of_subs_expr[ i].replace(dNf_dgN_not_yet_evaluated_expr[j], dNf_dgN_subs[j]) return dNf_dhN_in_terms_of_subs_expr