def test_itoEuler_1D_additive(): tspan = np.arange(0.0, 2000.0, 0.002) y0 = 0.0 f = lambda y, t: -1.0 * y G = lambda y, t: 0.2 y = sdeint.itoEuler(f, G, y0, tspan) assert(np.isclose(np.mean(y), 0.0, rtol=0, atol=1e-02)) assert(np.isclose(np.var(y), 0.2*0.2/2, rtol=1e-01, atol=0))
def test_itoEuler_1D_additive(): tspan = np.arange(0.0, 2000.0, 0.002) y0 = 0.0 f = lambda y, t: -1.0 * y G = lambda y, t: 0.2 y = sdeint.itoEuler(f, G, y0, tspan) assert (np.isclose(np.mean(y), 0.0, rtol=0, atol=1e-02)) assert (np.isclose(np.var(y), 0.2 * 0.2 / 2, rtol=1e-01, atol=0))
def solve(self, **kwargs): """ Solves initial value problem """ if (len(self.sol) == 0): # Solve only if not already solved if(self.method == 'EuMa'): self.sol_cartesian = sdeint.itoEuler(self.f, self.G, self.y0, self.ts, **kwargs) elif (self.method == 'Ito'): self.sol_cartesian = sdeint.itoint(self.f, self.G, self.y0, self.ts, **kwargs) elif (self.method == 'Strato'): self.sol_cartesian = sdeint.stratint(self.f, self.G, self.y0, self.ts, **kwargs) else: raise ValueError('Only supported methods are EuMa, Ito and Strato') else: # Do nothing pass if self.topology == 'cartesian': self.sol = self.sol_cartesian elif self.topology == 'torus': self.sol = np.mod(self.sol_cartesian, 2*np.pi)
def test_itoEuler_R74(self, exact_solution_R74): (dW, I, J, f, f_strat, G, G_separate, y0, tspan, y) = exact_solution_R74 yEuler = sdeint.itoEuler(f, G, y0, tspan, dW=dW) _assert_close(yEuler, y, 1e-1, 1e-1) return yEuler
def test_itoEuler_KPS445(self, exact_solution_KPS445): (dW, I, J, f, f_strat, G, y0, tspan, y) = exact_solution_KPS445 yEuler = sdeint.itoEuler(f, G, y0, tspan, dW=dW)[:, 0] _assert_close(yEuler, y, 1e-1, 1e-1) return yEuler
x_initial = np.ones(N) local_state = np.random.RandomState(1) noise = local_state.normal(0, np.sqrt(dt), (np.size(t) - 1, N)) * strength index_lattice = np.where(A != 0) A_interaction_lattice = A[index_lattice].reshape(N, degree) t1 = time.time() dyn = odeint(mutual, x, t, args=(N, index, neighbor, A_interaction)) t2 = time.time() dyn_lattice = odeint(mutual_lattice, x, t, args=(N, index_lattice, degree, A_interaction_lattice)) t3 = time.time() dyn_all = sdeint.itoEuler(close(mutual, *(N, index, neighbor, A_interaction)), close(eta_diag, *(N, )), x_initial, t, dW=noise) t4 = time.time() dyn_all_lattice = sdeint.itoEuler(close( mutual_lattice, *(N, index_lattice, degree, A_interaction_lattice)), close(eta_diag, *(N, )), x_initial, t, dW=noise) t5 = time.time() dyn_sde = sdesolver(close(mutual, *(N, index, neighbor, A_interaction)), x_initial, t, dW=noise) t6 = time.time()
def test_itoEuler_R74(self, exact_solution_R74): (dW, I, J, f, f_strat, G, G_separate, y0, tspan,y) = exact_solution_R74 yEuler = sdeint.itoEuler(f, G, y0, tspan, dW=dW) _assert_close(yEuler, y, 1e-1, 1e-1) return yEuler
def test_itoEuler_KPS445(self, exact_solution_KPS445): (dW, I, J, f, f_strat, G, y0, tspan, y) = exact_solution_KPS445 yEuler = sdeint.itoEuler(f, G, y0, tspan, dW=dW)[:,0] _assert_close(yEuler, y, 1e-1, 1e-1) return yEuler
def derive_functions(self, drift_order, diff_order, t_inc=None, T=None, m0=None, Dt='default', dt=1): """ Simulated to optimize the best fitting functional forms for the derrived drift and diffusion coefficients. Args ---- drift_order : int order of the drift coefficient observed diff_order : int order of the diffusion coefficient observed t_inc : float (or None) time increment for the SDE integration, if None time_increment will be taken as 1/autocorrelation time or the observed (input) timeseries T : int (or None) total time units of simulation, if None, T will be taken as the fraction of total time units of observed (input) data and its autocorrealtion time. m0 : float (or None) initial state of the SDE, if None, then m0 will be the first value of the input data Dt : list or 'default', 'all' list of drift timescales for to simulate reconstructed SDE and compare it with the observed data. If 'default', Dt = range(1, autocorrealtion_time+1, 10) if 'all', Dt will include all timescales for which the drift and diffusion coefficients are derrived. dt : int, (default = 1) diffusion time scale Returns ------- opt_F : callable drift polynomila function of the given order, and the timescale for which the simulated SDE's PDF was in close match with that of the observed. opt_G : callable diffusion polynomial function of the given order and timescale `dt`. Note ---- If the Dt set contains, timescale values for which the drift and diffusion coefficents have not been derrived, then such timescale values will be ignored. In other words, Dt set must be a subset of the set containing the slider timescales. """ if self.vector: print("Feature not implemented for vector data") return None if Dt == 'default': start, stop, n_steps = 1, self._ddsde.autocorrelation_time, 10 Dt = set(np.linspace(1, self._ddsde.autocorrelation_time, 10, dtype=np.int)) Dt = Dt.intersection(set(self._ddsde._avaiable_timescales)) elif Dt == 'all': Dt = list(self._ddsde._avaiable_timescales) else: Dt = set(Dt) Dt = Dt.intersection(set(self._ddsde._avaiable_timescales)) Dt = sorted(list(Dt)) if t_inc is None: t_inc = 1/self._ddsde.autocorrelation_time if T is None: T = int(np.ceil(len(self._data_X)/self._ddsde.autocorrelation_time)) t_span = np.arange(0, T, t_inc) pbar = tqdm.tqdm(total=len(Dt)) _g = self.fit("G", order=diff_order, diff_time_scale=dt) G = lambda x, t: _g(x) m0 = self._data_X[0] M = [] for i in Dt: _f = self.fit("F", order=drift_order, drift_time_scale=i) F = lambda x, t: _f(x) n = sdeint.itoEuler(F, G, m0, t_span) M.append(n.flatten()) pbar.update(1) pbar.close() M = np.array(M) divergence_list = [] p = self._data_X.copy() for q in M: divergence_list.append(self._divergence(p, q)) divergence_list = np.array(divergence_list) opt_Dt = divergence_list.argmin() + 1 fig = plt.figure(dpi=300) plt.plot(list(Dt), divergence_list) plt.xlabel('Dt') plt.ylabel('KL Divergence') plt.show() print("optimium time scale Dt : {}".format(opt_Dt)) opt_F = self.fit('F', order=drift_order, drift_time_scale=opt_Dt) opt_G = self.fit('G', order=diff_order, diff_time_scale=dt) print(opt_F) print(opt_G) return opt_F, opt_G, M,d