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))
