def main(y0='1,0', mu=1.0, tend=10., nt=50, savefig='None', plot=False,
savetxt='None', integrator='scipy', dpi=100, kwargs='',
verbose=False):
assert nt > 1
y = sp.symarray('y', 2)
p = sp.Symbol('p', real=True)
f = [y[1], -y[0] + p*y[1]*(1 - y[0]**2)]
odesys = SymbolicSys(zip(y, f), params=[p], names=True)
tout = np.linspace(0, tend, nt)
y0 = list(map(float, y0.split(',')))
kwargs = dict(eval(kwargs) if kwargs else {})
xout, yout, info = odesys.integrate(
tout, y0, [mu], integrator=integrator, **kwargs)
if verbose:
print(info)
if savetxt != 'None':
np.savetxt(stack_1d_on_left(xout, yout), savetxt)
if plot:
import matplotlib.pyplot as plt
odesys.plot_result()
plt.legend()
if savefig != 'None':
plt.savefig(savefig, dpi=dpi)
else:
plt.show()
def main(y0='1,0',
mu=1.0,
tend=10.,
nt=50,
savefig='None',
plot=False,
savetxt='None',
integrator='scipy',
dpi=100,
kwargs='',
verbose=False):
assert nt > 1
y = sp.symarray('y', 2)
p = sp.Symbol('p', real=True)
f = [y[1], -y[0] + p * y[1] * (1 - y[0]**2)]
odesys = SymbolicSys(zip(y, f), params=[p], names=True)
tout = np.linspace(0, tend, nt)
y0 = list(map(float, y0.split(',')))
kwargs = dict(eval(kwargs) if kwargs else {})
xout, yout, info = odesys.integrate(tout,
y0, [mu],
integrator=integrator,
**kwargs)
if verbose:
print(info)
if savetxt != 'None':
np.savetxt(stack_1d_on_left(xout, yout), savetxt)
if plot:
import matplotlib.pyplot as plt
odesys.plot_result()
plt.legend()
if savefig != 'None':
plt.savefig(savefig, dpi=dpi)
else:
plt.show()
def numerical_solver(left,
right,
y0,
params=[],
params_value=[],
tstart=0.,
tend=10.,
nt=100,
plot=False,
savetxt='None',
savefig='None',
integrator='scipy',
dpi=100,
kwargs='',
verbose=False):
'''
Пояснение:
y0 - начальные значения для переменных в виде строки 'X0,X1, ..., Xn'
tstart, tend, nt - начало, конец и количество шагов по времени соответственно
'''
'''
Zip группирует в соответствии левую и правую часть системы
x, y = 'x', 'y'
f = ['x**2 - y', 'y-y**3+x']
list(zip([x,y], f)) -> [('x', 'x**2 - y'), ('y', 'y-y**3+x')]
'''
odesys = SymbolicSys(zip(left, right), params=params, names=True)
''' Создаем точки по t'''
tout = np.linspace(tstart, tend, nt)
''' Преобразуем начальные условия '''
y0 = list(map(float, y0.split(',')))
'''kwargs пока не нужен'''
kwargs = dict(eval(kwargs) if kwargs else {})
''' Интегрируем '''
xout, yout, info = odesys.integrate(tout,
y0,
params_value,
integrator=integrator,
**kwargs)
return xout, yout, info
if verbose:
print(info)
if savetxt != 'None':
# stack_1d_on_left(xout, yout) -> [[t_0, x1_0, x2_0, x3_0], ... , [t_n, x1_n, x2_n, x3_n]]
np.savetxt(savetxt, stack_1d_on_left(xout, yout))
if plot:
odesys.plot_result()
plt.legend()
plt.figure(figsize=(20, 10))
if savefig != 'None':
plt.savefig(savefig, dpi=dpi)
else:
plt.show()
class TimeDoublePendulum:
def setup(self):
self.odesys = SymbolicSys(_get_equations(1, 9.81, 1))
self.tout = np.linspace(0, 10., 200)
self.y0 = [.1, .2, 0, 0]
def time_integrate_scipy(self):
self.odesys.integrate(self.tout, self.y0, integrator='scipy')
def time_integrate_gsl(self):
self.odesys.integrate(self.tout, self.y0, integrator='gsl')
def time_integrate_odeint(self):
self.odesys.integrate(self.tout, self.y0, integrator='odeint')
def time_integrate_cvode(self):
self.odesys.integrate(self.tout, self.y0, integrator='cvode')
class TimeDoublePendulum:
def setup(self):
self.odesys = SymbolicSys(_get_equations(1, 9.81, 1))
self.tout = np.linspace(0, 10., 200)
self.y0 = [.1, .2, 0, 0]
def time_integrate_scipy(self):
self.odesys.integrate(self.tout, self.y0, integrator='scipy')
def time_integrate_gsl(self):
self.odesys.integrate(self.tout, self.y0, integrator='gsl')
def time_integrate_odeint(self):
self.odesys.integrate(self.tout, self.y0, integrator='odeint')
def time_integrate_cvode(self):
self.odesys.integrate(self.tout, self.y0, integrator='cvode')
def main(m=1, g=9.81, l=1, q1=.1, q2=.2, u1=0, u2=0, tend=10., nt=200,
savefig='None', plot=False, savetxt='None', integrator='scipy',
dpi=100, kwargs="", verbose=False):
assert nt > 1
kwargs = dict(eval(kwargs) if kwargs else {})
odesys = SymbolicSys(get_equations(m, g, l))
tout = np.linspace(0, tend, nt)
y0 = [q1, q2, u1, u2]
xout, yout, info = odesys.integrate(
tout, y0, integrator=integrator, **kwargs)
if verbose:
print(info)
if savetxt != 'None':
np.savetxt(stack_1d_on_left(xout, yout), savetxt)
if plot:
import matplotlib.pyplot as plt
odesys.plot_result(xout, yout)
if savefig != 'None':
plt.savefig(savefig, dpi=dpi)
else:
plt.show()
def main(m=1,
g=9.81,
l=1,
q1=.1,
q2=.2,
u1=0,
u2=0,
tend=10.,
nt=200,
savefig='None',
plot=False,
savetxt='None',
integrator='scipy',
dpi=100,
kwargs="",
verbose=False):
assert nt > 1
kwargs = dict(eval(kwargs) if kwargs else {})
odesys = SymbolicSys(get_equations(m, g, l))
tout = np.linspace(0, tend, nt)
y0 = [q1, q2, u1, u2]
xout, yout, info = odesys.integrate(tout,
y0,
integrator=integrator,
**kwargs)
if verbose:
print(info)
if savetxt != 'None':
np.savetxt(stack_1d_on_left(xout, yout), savetxt)
if plot:
import matplotlib.pyplot as plt
odesys.plot_result(xout, yout)
if savefig != 'None':
plt.savefig(savefig, dpi=dpi)
else:
plt.show()
Derivative(alpha, t): eq['dot(alpha)'],
alpha: eq['alpha']}).\
doit()
eq['dot(theta)'][i] = eq['dot(theta)'][i].\
subs({nu[1]: eq['nu1'],
nu[2]: eq['nu2'],
Derivative(alpha, t): eq['dot(alpha)'],
alpha: eq['alpha']}).\
doit()
psi0, psi1, psi2, theta0, theta1, theta2, x, y, alpha = symbols('psi_0, psi_1, psi_2, theta_0, theta_1, theta_2, x, y, alpha')
for i in range(3):
eq['dot(psi)'][i] = subs_symbols(eq['dot(psi)'][i])
eq['dot(theta)'][i] = subs_symbols(eq['dot(theta)'][i])
left = [psi0, psi1, psi2, theta0, theta1, theta2]
right = [eq['dot(psi)'][0], eq['dot(psi)'][1], eq['dot(psi)'][2], eq['dot(theta)'][0], eq['dot(theta)'][1], eq['dot(theta)'][2]]
print(right)
print('Количество совпадает:', len(left) == len(right))
odesys = SymbolicSys(list(zip(left, right)), t, [p, r, d])
xout, yout, info = odesys.integrate(t_end,
initial_conditions,
params,
integrator='gsl',
method='rk8pd',
atol=1e-11,
rtol=1e-12)
return xout, yout, info, left, right
class Dynamical(Parametrized, metaclass=DynamicalMeta, vars=None):
graph = GraphAttrDict()
_node = NodeDict()
_adj = AdjlistOuterDict()
_pred = AdjlistOuterDict()
def __init__(self, *args, integrator=None, use_native=False, **kwargs):
super().__init__(*args, **kwargs)
self.use_native = use_native
self.integrator = integrator
self._sys = None
self._stale_dynamics = True
self._native_sys = None
def expire_dynamics(self):
self._stale_dynamics = True
@abc.abstractmethod
def rhs(self):
pass
@property
def t(self):
return sym.Symbol('t')
@property
def vars(self):
return self._vars
@property
@uses_dynamics
def sys(self):
return self._sys
@property
@uses_dynamics
def native_sys(self):
return self._native_sys
@property
def stale_dynamics(self):
return self._stale_dynamics
@uses_dynamics
def f(self, t, y):
sys = self.native_sys if self.use_native else self.sys
return sys.f_cb(t, y)
@uses_dynamics
def jac(self, t, y):
sys = self.native_sys if self.use_native else self.sys
return sys.j_cb(t, y)
@uses_dynamics
def jtimes(self, t, y, v):
sys = self.native_sys if self.use_native else self.sys
return sys.jtimes_cb(t, y, v)
def update_dynamics(self):
eqs = dict(self.rhs())
keys = set(eqs.keys())
symvars = [getattr(self, v) for v in self.vars]
if keys <= set(self.nodes):
# by node
dep = flatten(zip(*symvars))
expr = flatten(sym.Matrix([eqs[node] for node in self]))
elif keys <= set(self.vars):
# by variable
dep = it.chain.from_iterable(symvars)
expr = flatten(sym.Matrix([eqs[v] for v in self.vars]))
else:
raise ValueError(
"rhs must map either nodes to rhs or variables to rhs")
dep_expr = [(d, e + Zero()) for d, e in zip(dep, expr)]
if any(expr == sym.nan for _, expr in dep_expr):
raise ValueError(
"At least one rhs expression is NaN. Missing parameters?")
self._sys = SymbolicSys(dep_expr, self.t)
if self.use_native:
self._native_sys = native_sys[self.integrator].from_other(
self._sys)
self._stale_dynamics = False
@uses_dynamics
def integrate(self, *args, **kwargs):
if self.use_native:
return self._native_sys.integrate(*args, **kwargs)
else:
kw = dict(integrator=self.integrator)
kw.update(kwargs)
return self._sys.integrate(*args, **kw)
