def test_splitting_gf(): parent = Tiling( obstructions=( GriddedPerm.single_cell((0, 1), (0, 1)), GriddedPerm.single_cell((0, 1), (1, 0)), ), assumptions=( TrackingAssumption([ GriddedPerm.point_perm((0, 1)), GriddedPerm.point_perm((1, 0)) ]), TrackingAssumption([GriddedPerm.point_perm((1, 0))]), ), ) child = Tiling( obstructions=( GriddedPerm.single_cell((0, 1), (0, 1)), GriddedPerm.single_cell((0, 1), (1, 0)), ), assumptions=( TrackingAssumption([GriddedPerm.point_perm((0, 1))]), TrackingAssumption([GriddedPerm.point_perm((1, 0))]), ), ) strat = SplittingStrategy() rule = strat(parent) x, k0, k1 = var("x k_0 k_1") parent_func = Function("F_0")(x, k0, k1) child_func = Function("F_1")(x, k0, k1) expected_eq = Eq(parent_func, child_func.subs({k1: k0 * k1})) assert len(rule.children) == 1 assert rule.children[0] == child assert rule.constructor.get_equation(parent_func, (child_func, )) == expected_eq
def normalization(func: sp.Function, variable: sp.Symbol, bottom_bound: float, top_bound: float) -> (sp.Function, sp.Symbol): t = sp.Symbol('t') func_normalized = func.subs(variable, (top_bound + bottom_bound + t*(top_bound - bottom_bound))/2) return func_normalized, t
# symbols t = Symbol('t', positive=True) zeta = Symbol('\zeta', positive=True) omegan = Symbol('\omega_n', positive=True) omegad = Symbol('\omega_d', positive=True) epsilon = Symbol(r'\varepsilon', positive=True) tn = Symbol('t_n', positive=True) P0 = Symbol('P0') m = Symbol('m', positive=True) u0 = 0 v0 = 0 # unknown function u = Function('u')(t) # solving ODE (mass-normalized EOM) f = P0*sympy.DiracDelta(t-tn) ics = {u.subs(t, 0): u0, u.diff(t).subs(t, 0): v0, } sol = dsolve(u.diff(t, t) + 2*zeta*omegan*u.diff(t) + omegan**2*u - f/m, ics=ics) display(sympy.simplify(sol.rhs)) from sympy.plotting import plot plot(sol.rhs.subs({omegan: 10, zeta: 0.1, tn: 3, P0: 1, m: 3}), (t, 0, 10), adaptive=False, nb_of_points=1000, ylabel='$u(t)$')
GCodeFile = open('C:\\3D Printer Calculus Project\\docs\\Sample.txt', 'w+') x = Symbol('x') f = Function('f')(x) f = 0.5*x xVals = [] yVals = [] zVals = [] SideArray = [] TotalVolume = 0 AxisChoice = gui.AxisRevScreen() if AxisChoice == "X-axis": Bounds = gui.BoundsScreen() FirstBound = int(Bounds[0]) FinalBound = int(Bounds[1]) xInitialVal = FirstBound yInitialVal = f.subs(x, FirstBound) zInitialVal = 0 xVals.append(xInitialVal) yVals.append(yInitialVal) zVals.append(zInitialVal) FinalBound1 = int(FinalBound * 10) FirstBound1 = int(FirstBound * 10) for t in range (FirstBound1, FinalBound1): ### This for loop generates the x coordinates ### if t % 2 == 0: xVal = t/10.0 for i in range (1,37): ###This for loop generates the y and z coordinates for each x coordinate when the graph is spun around### newYVal = f.subs(x, xVal) * np.cos((3.14159265359*i)/18) newZVal = f.subs(x, xVal) * np.sin((3.14159265359*i)/18) yVals.append(newYVal)
import sympy from sympy import Function, dsolve, Symbol # symbols t = Symbol('t', positive=True) # unknown function u = Function('u')(t) # solving ODE with initial conditions u0 = 0.4 v0 = 2 k = 150 m = 2 ics = {u.subs(t, 0): u0, u.diff(t).subs(t, 0): v0} sol = dsolve(m * u.diff(t, t) + k * u, ics=ics) import matplotlib matplotlib.use('TkAgg') from sympy.plotting import plot p1 = plot(sol.rhs, (t, 0, 1), xlabel='$t$', ylabel='$u(t)$')
zeta = Symbol('zeta', positive=True) # unknown function u = Function('u')(t) # assumed values wn = 5. u0 = 1 v0 = 0 wf = wn * r f0 = 10. # solving ODE f = f0 * sympy.cos(wf * t) ics = { u.subs(t, 0): u0, u.diff(t).subs(t, 0): v0, } sol = dsolve(u.diff(t, t) + 2 * zeta * wn * u.diff(t) + wn**2 * u - f, ics=ics) import matplotlib matplotlib.use('TkAgg') from sympy.plotting import plot3d subs = {zeta: 0.2} p1 = plot3d( sol.rhs.subs(subs), (t, 0, 10), (r, 0.1, 2), show=False, nb_of_points_x=250,
from sympy import Function, Symbol, Eq, Derivative, dsolve, solveset, solve from sympy.parsing.sympy_parser import parse_expr # Task: find meeting point between a value (constant function) and a function y # the function y has to first be found as a solution of a differential equation # inputs: function definition (string), variables (string - if needed), constant value (string bc of zmq if possible) function_string = "exp(t)*y(t)" function_name = "y" function_variable = "t" initial_x = 0.0 initial_f = 1.0 # can be multiple and we could split on comma etc other_symbols = "a" constant = 1.0 x = Symbol(function_variable) f = Function(function_name)(x) f_strich = Derivative(f, x) function_definition = parse_expr(function_string, evaluate=False) print('f def:', function_definition) eq = Eq(f_strich, function_definition) print('eq:', eq) solution = dsolve(eq, ics={f.subs(x, initial_x): initial_f}) print('solution:', solution) second_eq = Eq(solution.rhs, constant) intersection = solve(second_eq) print('intersection:', intersection)
pretty_print('''\n For outer:''') r1 = symbols('r1') der_m = m.diff(r).subs(r, r1) pretty_print(Eq(psi_2, Integral(-G * der_m / r1, (r1, r, R)))) p2 = integrate(-G * der_m / r1, (r1, r, R)) p2 = simplify(p2) eq_psi = eq_psi.subs(psi_2, p2) pretty_print(simplify(eq_psi)) pretty_print('''Then: ''') psi = solve(eq_psi, psi)[0] # assert edge case for r = R assert psi.subs(r, R) + G * M / R == 0 C = Function('C')(r) pretty_print(Eq(C, -Derivative(Function('psi')(r), r))) eq_C = Eq(C, -psi.diff(r)) pretty_print(eq_C) C = solve(eq_C, C)[0] # assert edge case for r = R assert C.subs(r, R) + G * M / R**2 == 0 # suppose we wave such unis that GM /R **3 = 1, and R = 1 # plot potential `psi` vs distance to the center, r: rs = np.linspace(0., 1.)
def __setitem__(self, sym_name, input_expr): """Assigns a function or expression to a new symbol, performs unit conversion where appropriate """ if not isinstance(sym_name, str): sym_name = str(sym_name) symbol, args, lhs_units, lhs_expr = self.parse_key(sym_name) if hasattr(input_expr, '__call__'): self.register_function(input_expr, symbol, lhs_expr, lhs_units) else: if self.verbose: print( "\n\nPARSING WITH UNIFY", lhs_expr, symbol, lhs_units, len(lhs_units), type(lhs_units)) print('symbol registry:', self.symbol_registry) rhs_expr = self.parse_value(input_expr, self.symbol_registry) if self.verbose: print('parsed rhs_expr', rhs_expr) if not isinstance(symbol, Symbol): if isinstance(lhs_expr, Symbol): symbol = Function(lhs_expr)(*tuple(rhs_expr.free_symbols)) else: #lhs is already a function symbol = lhs_expr lhs_str = str(symbol) sym_name = sym_name.replace(str(lhs_expr), lhs_str) if self.verbose: print('unit registry contents:') for k, v in self.unit_registry.items(): print('\t', k, type(k), v) if '[' in sym_name: if self.verbose: print('updating unit registry with {} -> {}'.format(sym_name, rhs_expr)) rhs = rhs_expr arg_units = get_arg_units(rhs_expr, self.unit_registry) if self.verbose: print(arg_units) sym_name = self.update_unit_registry(sym_name, arg_units) if self.verbose: print('unit registry update returned', sym_name, self.unit_registry.get(symbol)) else: if self.verbose: print(sym_name, symbol, 'had no units. Getting units from {}'.format(rhs_expr)) expr_unit = get_expr_unit(rhs_expr, self.unit_registry, self.verbose) arg_units = get_arg_units(rhs_expr, self.unit_registry) if self.verbose: print('registering {} with {} {}'.format(symbol, expr_unit, arg_units)) if (symbol not in self.unit_registry) and (expr_unit is not None): self.unit_registry[symbol] = symbol.subs(arg_units) self.unit_registry[symbol.subs(arg_units)] = expr_unit if expr_unit is not None: expr_dimensions = Dimension(get_dimensions(expr_unit)) if expr_dimensions != Dimension(1): lhs_units = str(get_abbrev(get_expr_unit( expr_unit, self.unit_registry, self.verbose))) else: lhs_units = '' if self.verbose: print('registered lhs_units', lhs_units) rhs = rhs_expr sym_name = str(sym_name) if len(lhs_units) > 0: if self.verbose: print('about to unify lhs_units {} {} with {}'.format( lhs_units, type(lhs_units), rhs)) expr = unify( Eq(parse_expr(sym_name), rhs), self.unit_registry, # to_symbol = symbol, verbose=self.verbose) rhs_expr = expr.rhs if self.verbose: print('symbol after unify', symbol, type(symbol), rhs_expr) print('unit registry to resolve units:') for k,v in self.unit_registry.items(): print('\t{}:{}'.format(k,v)) units = get_expr_unit(symbol, self.unit_registry) if Dimension(get_dimensions(units)) != Dimension(1): units = get_abbrev(units) if units is not None: units = str(units) else: units = '' else: units = '' if self.verbose: print('units after resolve', symbol, units) for k, v in self.unit_registry.items(): print('\t{}: {}'.format(k, v)) rhs_args = rhs_expr.free_symbols symbol = self.check_or_replace_symbol(symbol, rhs_args, rhs_expr) self.validate_function(symbol, rhs_expr) composition = {str(k_): self[k_] for k_ in self} arg_units = {} if symbol in self.unit_registry: unit_args = self.unit_registry[symbol] if unit_args is not None: if len(unit_args.args) == len(symbol.args): for arg, unit in zip(symbol.args, unit_args.args): arg_units[str(arg)] = str(get_abbrev(unit)) func = self.vectorize_function(symbol, rhs_expr, composition) meta = dict(units=units, arg_units=arg_units) func.meta = meta func.data = None self.register_signature(symbol, units, lhs_expr, rhs_expr) func._repr_latex_ = lambda: self.func_latex(str(type(symbol)), mode='inline') super(Kamodo, self).__setitem__(symbol, func) super(Kamodo, self).__setitem__(type(symbol), self[symbol]) self.register_symbol(symbol)
def test_fusion_gfs(): x = var("x") k_0 = var("k_0") k_1 = var("k_1") def eq_equality(e1, e2): return (e1.rhs - e2.rhs).simplify() == 0 t1 = easy_fusable() rules = list(FusionFactory()(t1)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t2 = easy_fusable(track_left=True) rules = list(FusionFactory()(t2)) assert len(rules) == 1 F0 = Function("F0")(x) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - F1.subs({k_0: 1})) / (k_0 - 1)) assert eq_equality(actual_eq, expected_eq) t3 = easy_fusable(track_left=True, track_right=True, same_tracking=True) rules = list(FusionFactory()(t3)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t4 = easy_fusable(track_left=True, track_right=True, same_tracking=False) rules = list(FusionFactory()(t4)) assert len(rules) == 1 F0 = Function("F0")(x, k_0, k_1) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - k_1 * F1.subs({k_0: k_1})) / (k_0 - k_1)) assert eq_equality(actual_eq, expected_eq) t5 = easy_fusable(pos_left=True) rules = list(FusionFactory()(t5)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t6 = easy_fusable(pos_left=True, track_left=True) rules = list(FusionFactory()(t6)) assert len(rules) == 1 F0 = Function("F0")(x, k_0) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - F1.subs({k_0: 1})) / (k_0 - 1) - F1.subs({k_0: 1})) assert eq_equality(actual_eq, expected_eq) t7 = easy_fusable(pos_left=True, track_right=True) rules = list(FusionFactory()(t7)) assert len(rules) == 1 F0 = Function("F0")(x, k_0) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - F1.subs({k_0: 1})) / (k_0 - 1) - F1) assert eq_equality(actual_eq, expected_eq) t8 = easy_fusable(pos_left=True, track_left=True, track_right=True, same_tracking=True) rules = list(FusionFactory()(t8)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t9 = easy_fusable(pos_left=True, track_left=True, track_right=True, same_tracking=False) rules = list(FusionFactory()(t9)) assert len(rules) == 1 F0 = Function("F0")(x, k_0, k_1) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - k_1 * F1.subs({k_0: k_1})) / (k_0 - k_1) - F1.subs({k_0: k_1})) assert eq_equality(actual_eq, expected_eq) t10 = easy_fusable(pos_right=True, track_left=True, track_right=True, same_tracking=False) rules = list(FusionFactory()(t10)) assert len(rules) == 1 F0 = Function("F0")(x, k_0, k_1) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - k_1 * F1.subs({k_0: k_1})) / (k_0 - k_1) - F1) assert eq_equality(actual_eq, expected_eq) t11 = easy_fusable(pos_left=True, pos_right=True) rules = list(FusionFactory()(t11)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t12 = easy_fusable(pos_left=True, pos_right=True, track_left=True) rules = list(FusionFactory()(t12)) assert len(rules) == 1 F0 = Function("F0")(x, k_0) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq(F0, (k_0 * F1 - F1.subs({k_0: 1})) / (k_0 - 1) - F1 - F1.subs({k_0: 1})) assert eq_equality(actual_eq, expected_eq) t13 = easy_fusable( pos_left=True, pos_right=True, track_left=True, track_right=True, same_tracking=True, ) rules = list(FusionFactory()(t13)) assert len(rules) == 1 # EQ NOT IMPLEMENTED t14 = easy_fusable( pos_left=True, pos_right=True, track_left=True, track_right=True, same_tracking=False, ) rules = list(FusionFactory()(t14)) assert len(rules) == 1 # EQ NOT IMPLEMENTED F0 = Function("F0")(x, k_0, k_1) F1 = Function("F1")(x, k_0) actual_eq = rules[0].constructor.get_equation(F0, (F1, )) expected_eq = Eq( F0, (k_0 * F1 - k_1 * F1.subs({k_0: k_1})) / (k_0 - k_1) - F1 - F1.subs({k_0: k_1}), ) assert eq_equality(actual_eq, expected_eq)
Eqns = [[] for _ in range(int(order / 2))] solns = [[] for _ in range(int(order / 2))] for i in range(order + 1): print(i) Exp = series((sigb - S)**i - (((sigb + S) * (1 + a) / 2 - S)**i + ((sigb + S) * (1 - a) / 2 - S)**i) * exp(-Lambdap * tau), x=sigb, x0=S, n=order + 1) Exp = Exp.removeO() lam_exp = 1 for j in range(len(Cs)): lam_exp += Cs[j] * a**(2 * (j + 1)) Exp = Exp.subs(Lambdap, log(2) / tau.subs(sigb, S) * lam_exp) const = series(Exp, x=sigb, x0=S, n=1).removeO() Exp2 = const for k in range(int(order / 2)): for m in range(k, int(order / 2)): Exp2 += Exp.coeff(sigb - S, 2 * k + 1) * Ds[m][2 * k] * a**(2 * m + 2) Exp2 += Exp.coeff(sigb - S, 2 * k + 2) * Ds[m][2 * k + 1] * a**(2 * m + 2) Exp2 = series(Exp2, x=a, x0=0, n=order + 1).removeO() for m in np.arange(int(order / 2)): coef = Exp2.coeff(a, m * 2 + 2) if coef != 0: p = Poly(coef, tuple([Cs[m]] + Ds[m]))
Oppgave 2 """ from sympy import Function, Derivative, dsolve, solve, Eq, symbols, diff t, k = symbols( 't,k', real=True ) # Trenger argumentet real for aa unngaa aa haantere komplekse losninger print("\nOppgave 2 b)") M = Function('M')(t) M_ = Derivative(M, t) Eqn = M_ - k * M M0 = 100 t_ = 0 sol = dsolve(Eqn, ics={M.subs(t, t_): M0}) uttrykk = sol.rhs print("Losningen blir:", uttrykk, "for M(%.1f) = %.1f" % (t_, M0)) M6 = 97 t_ = 6 print("Loser", uttrykk, "for k, for M(%5.2f) = %.2f" % (t_, M6)) uttrykk_2 = uttrykk.subs(t, t_) #k_verdi = float(solve(Eq(uttrykk_2, M6),k)[-1]) k_verdi = float(solve(Eq(uttrykk_2, M6), k)[0]) uttrykk_med_k = uttrykk.subs(k, k_verdi) print("M(t) =", uttrykk_med_k) print("\nOppgave 2 c)") M__ = 2 uttrykk_3 = Eq(uttrykk, M__) t_ = float(solve(uttrykk_3, t)[0].subs(
def __setitem__(self, sym_name, input_expr): """Assigns a function or expression to a new symbol, performs unit conversion where appropriate """ if not isinstance(sym_name, str): sym_name = str(sym_name) symbol, args, lhs_units, lhs_expr = self.parse_key(sym_name) # if self.verbose: # print('') # try: # symbol, args, lhs_units, lhs_expr = self.parse_key(sym_name) # except KeyError as error: # if self.verbose: # print('could not use parse_key with {}'.format(sym_name)) # print(error) # found_sym_name = str(error).split('found')[0].strip("'").strip(' ') # if self.verbose: # print('__setitem__: replacing {}'.format(found_sym_name)) # self.remove_symbol(found_sym_name) # symbol, args, lhs_units, lhs_expr = self.parse_key(sym_name) if hasattr(input_expr, '__call__'): self.register_function(input_expr, symbol, lhs_expr, lhs_units) else: if self.verbose: print("\n\nPARSING WITH UNIFY", lhs_expr, symbol, lhs_units, len(lhs_units), type(lhs_units)) print('symbol registry:', self.symbol_registry) rhs_expr = self.parse_value(input_expr, self.symbol_registry) if self.verbose: print('parsed rhs_expr', rhs_expr) if not isinstance(symbol, Symbol): if isinstance(lhs_expr, Symbol): symbol = Function(lhs_expr)(*tuple(rhs_expr.free_symbols)) else: #lhs is already a function symbol = lhs_expr lhs_str = str(symbol) sym_name = sym_name.replace(str(lhs_expr), lhs_str) if self.verbose: print('unit registry contents:') for k, v in self.unit_registry.items(): print('\t', k, type(k), v) if '[' in sym_name: if self.verbose: print('updating unit registry with {} -> {}'.format( sym_name, rhs_expr)) rhs = rhs_expr arg_units = get_arg_units(rhs_expr, self.unit_registry) if self.verbose: print(arg_units) sym_name = self.update_unit_registry(sym_name, arg_units) if self.verbose: print('unit registry update returned', sym_name, self.unit_registry.get(symbol)) else: # if symbol in self.unit_registry: # units = get_expr_unit(symbol, self.unit_registry) # if self.verbose: # print('{} has units {}'.format(sym_name, units)) # else: if self.verbose: print( sym_name, symbol, 'had no units. Getting units from {}'.format(rhs_expr)) expr_unit = get_expr_unit(rhs_expr, self.unit_registry, self.verbose) arg_units = get_arg_units(rhs_expr, self.unit_registry) # if expr_unit == Dimension(1): # expr_unit = None if self.verbose: print('registering {} with {} {}'.format( symbol, expr_unit, arg_units)) if (symbol not in self.unit_registry) and (expr_unit is not None): self.unit_registry[symbol] = symbol.subs(arg_units) self.unit_registry[symbol.subs(arg_units)] = expr_unit # if is_function(expr_unit): # self.unit_registry[expr_unit] = get_expr_unit( # expr_unit, # self.unit_registry, # self.verbose) if expr_unit is not None: lhs_units = str( get_abbrev( get_expr_unit(expr_unit, self.unit_registry, self.verbose))) if self.verbose: print('registered lhs_units', lhs_units) rhs = rhs_expr sym_name = str(sym_name) if len(lhs_units) > 0: if self.verbose: print('about to unify lhs_units {} {} with {}'.format( lhs_units, type(lhs_units), rhs)) expr = unify( Eq(parse_expr(sym_name), rhs), self.unit_registry, # to_symbol = symbol, verbose=self.verbose) rhs_expr = expr.rhs if self.verbose: print('symbol after unify', symbol, type(symbol), rhs_expr) print('unit registry to resolve units:', self.unit_registry) units = get_expr_unit(symbol, self.unit_registry) units = get_abbrev(units) if units is not None: units = str(units) else: units = '' if self.verbose: print('units after resolve', symbol, units) for k, v in self.unit_registry.items(): print('\t{}: {}'.format(k, v)) rhs_args = rhs_expr.free_symbols # try: symbol = self.check_or_replace_symbol(symbol, rhs_args, rhs_expr) self.validate_function(symbol, rhs_expr) # except: # if self.verbose: # print('\n Error in __setitem__', input_expr) # print(symbol, lhs_expr, rhs_args) # print('symbol registry:', self.symbol_registry) # print('signatures:', self.signatures) # print('unit registry:', self.unit_registry) # raise # composition = self.get_composition(lhs_expr, rhs_expr) composition = {str(k_): self[k_] for k_ in self} arg_units = {} if symbol in self.unit_registry: unit_args = self.unit_registry[symbol] if unit_args is not None: if len(unit_args.args) == len(symbol.args): for arg, unit in zip(symbol.args, unit_args.args): arg_units[str(arg)] = str(get_abbrev(unit)) func = self.vectorize_function(symbol, rhs_expr, composition) meta = dict(units=units, arg_units=arg_units) func.meta = meta func.data = None self.register_signature(symbol, units, lhs_expr, rhs_expr) super(Kamodo, self).__setitem__(symbol, func) super(Kamodo, self).__setitem__(type(symbol), self[symbol]) self.register_symbol(symbol)
from sympy import Function, Symbol, Eq, exp, Derivative, dsolve, solveset from sympy.parsing.sympy_parser import parse_expr #from sympy.functions.elementary.exponential import exp #create an undefined function t = Symbol('t') #oder f = Function('f')(x) # build the derivative of a function with f(x).diff(x) # or directly with Derivative(f, x) # both give you the same thing for an undefined function y = Function('y')(t) y_strich = Derivative(y, t) print('ystrich', y_strich) # Eq forms an Equality eq = Eq(y_strich, parse_expr('exp(t)*y(t)', evaluate=False)) print(eq) # dsolve without starting value gives us solution involving C1 eg print(dsolve(eq, ics={y.subs(t, 0): 1})) # converts string to sympy expression # print(parse_expr('exp(t)*y(t)', evaluate=False))