Esempio n. 1
0
    def generate_f_lambda(self):
        """
			Prepares a purely Python-based integrator.
		"""

        self.DDE = python_core.dde_integrator(self.f_sym, self.past,
                                              self.helpers)
Esempio n. 2
0
	def test_integration(self):
		past = past_generator()
		double_past = []
		for entry in past:
			double_past += [(
				entry[0],
				np.hstack((entry[1],entry[1])),
				np.hstack((entry[2],entry[2]))
				)]
		
		self.DDE = dde_integrator(lambda: chain(f(),f()), double_past)
		
		self.assertEqual(self.DDE.y[0], y0)
		self.assertEqual(self.DDE.diff[0], dy0)
		self.assertEqual(self.DDE.y[1], y0)
		self.assertEqual(self.DDE.diff[1], dy0)
		self.assertEqual(self.DDE.t, 0.0)
		
		self.DDE.get_next_step(1.0)
		
		self.assertEqual(self.DDE.y[0], y0)
		self.assertEqual(self.DDE.diff[0], dy0)
		self.assertEqual(self.DDE.y[1], y0)
		self.assertEqual(self.DDE.diff[1], dy0)
		self.assertEqual(self.DDE.t, 0.0)
		self.assertAlmostEqual(self.DDE.error[1], expected_error)
		
		self.DDE.accept_step()
		
		self.assertAlmostEqual(self.DDE.y[0], expected_y)
		self.assertAlmostEqual(self.DDE.y[1], expected_y)
		self.assertEqual(self.DDE.t, 1.0)
Esempio n. 3
0
	def test_integration(self):
		past = past_generator()
		double_past = []
		for entry in past:
			double_past += [(
				entry[0],
				np.hstack((entry[1],entry[1])),
				np.hstack((entry[2],entry[2]))
				)]
		
		self.DDE = dde_integrator(lambda: chain(f(),f()), double_past)
		
		self.assertEqual(self.DDE.y[0], y0)
		self.assertEqual(self.DDE.diff[0], dy0)
		self.assertEqual(self.DDE.y[1], y0)
		self.assertEqual(self.DDE.diff[1], dy0)
		self.assertEqual(self.DDE.t, 0.0)
		
		self.DDE.get_next_step(1.0)
		
		self.assertEqual(self.DDE.y[0], y0)
		self.assertEqual(self.DDE.diff[0], dy0)
		self.assertEqual(self.DDE.y[1], y0)
		self.assertEqual(self.DDE.diff[1], dy0)
		self.assertEqual(self.DDE.t, 0.0)
		self.assertAlmostEqual(self.DDE.error[1], expected_error)
		
		self.DDE.accept_step()
		
		self.assertAlmostEqual(self.DDE.y[0], expected_y)
		self.assertAlmostEqual(self.DDE.y[1], expected_y)
		self.assertEqual(self.DDE.t, 1.0)
Esempio n. 4
0
	def test_jump(self):
		n = 10
		τ = 10
		width = 10**np.random.uniform(-7,0)*τ
		factor = np.random.random(n)
		
		times = sorted(np.random.uniform(0,τ,5))
		past = Past(n, [
				(time,np.random.random(n),0.1*np.random.random(n))
				for time in times
			])
		jump_time = np.random.uniform(past[-2][0],past[-1][0])
		jump_size = np.random.random(n)
		
		# Use a derivative for which it is clear how a jump affects it:
		f = lambda: [ factor[i]*y(i) + y(i,t-τ) for i in range(n) ]
		self.DDE = dde_integrator(f,past)
		
		state = self.DDE.get_recent_state(jump_time+width)
		derivative = self.DDE.eval_f(jump_time+width,state)
		
		self.DDE.apply_jump(jump_size,jump_time,width)
		
		assert self.DDE[-1][0] == jump_time+width
		assert_allclose( self.DDE[-1][1], state+jump_size )
		assert_allclose( self.DDE[-1][2], derivative+factor*jump_size )
Esempio n. 5
0
    def generate_lambdas(self):
        """
		Explicitly initiates a purely Python-based integrator.
		"""

        assert len(
            self.past) > 1, "You need to add at least two past points first."

        self.DDE = python_core.dde_integrator(self.f_sym, self.past,
                                              self.helpers, self.control_pars,
                                              self.n_basic)
        self.compile_attempt = False
Esempio n. 6
0
	def setUp(self):
		self.n_basic = 3
		self.n = 6*self.n_basic
		
		self.past = []
		for i in range(np.random.randint(3,10)):
			if i==0:
				time = np.random.uniform(-10,10)
			else:
				time = self.past[-1][0] + 0.1 + np.random.random()
			state = np.random.random(self.n)
			diff  = np.random.random(self.n)
			self.past.append((time, state, diff))
		
		self.DDE = dde_integrator(lambda: [], self.past, n_basic=self.n_basic)
		self.DDE.n = self.n
Esempio n. 7
0
	def setUp(self):
		self.n_basic = 3
		self.n = 6*self.n_basic
		
		self.past = []
		for i in range(np.random.randint(3,10)):
			if i==0:
				time = np.random.uniform(-10,10)
			else:
				time = self.past[-1][0] + 0.1 + np.random.random()
			state = np.random.random(self.n)
			diff  = np.random.random(self.n)
			self.past.append((time, state, diff))
		
		self.DDE = dde_integrator(lambda: [], self.past, n_basic=self.n_basic)
		self.DDE.n = self.n
Esempio n. 8
0
	def setUpClass(self):
		self.DDE = dde_integrator(lambda: [], past[:])
		self.DDE.anchor_mem = np.ones(1000, dtype=int)
Esempio n. 9
0
	def setUpClass(self):
		self.DDE = dde_integrator(lambda: [], past)
Esempio n. 10
0
	def setUp(self):
		self.DDE = dde_integrator(f_alt, past_generator(), f_alt_helpers)
Esempio n. 11
0
	def setUp(self):
		self.DDE = dde_integrator(f, past_generator())
Esempio n. 12
0
	def setUpClass(self):
		self.DDE = dde_integrator(lambda: [], past[:])
		self.DDE.anchor_mem = np.ones(1000, dtype=int)
Esempio n. 13
0
	def setUp(self):
		self.DDE = dde_integrator(f_alt, past_generator(), f_alt_helpers)
Esempio n. 14
0
	def setUp(self):
		self.DDE = dde_integrator(f, past_generator())