def setUp(self):
initrv = Constant(20 * np.ones(2))
self.ivp = lotkavolterra([0.0, 0.5], initrv)
step = 0.1
f = self.ivp.rhs
t0, tmax = self.ivp.timespan
y0 = self.ivp.initrv.mean
self.solution = probsolve_ivp(f,
t0,
tmax,
y0,
algo_order=3,
step=step,
adaptive=False)
def test_lorenz(self):
"""Test the Lorenz model ODE convenience function."""
rv = Constant(np.array([1.0, 1.0, 1.0]))
lg1 = ivp_examples.lorenz(self.tspan, rv)
lg2 = ivp_examples.lorenz(
self.tspan,
rv,
params=(
10.0,
28.0,
8.0 / 3.0,
),
)
self.assertIsInstance(lg1, ivp.IVP)
self.assertIsInstance(lg2, ivp.IVP)
def setUp(self):
def rhs_(t, x):
return -x
def jac_(t, x):
return -np.eye(len(x))
def sol_(t):
return np.exp(-t) * np.ones(TEST_NDIM)
some_center = np.random.rand(TEST_NDIM)
rv = Constant(some_center)
self.mockivp = ivp.IVP((0.0, np.random.rand()),
rv,
rhs=rhs_,
jac=jac_,
sol=sol_)
def test_fitzhughnagumo_jacobian(self):
rv = Constant(np.ones(2))
lg1 = ivp_examples.fitzhughnagumo(self.tspan, rv)
random_direction = 1 + 0.1 * np.random.rand(lg1.dimension)
random_point = 1 + np.random.rand(lg1.dimension)
fd_approx = (
0.5
* 1.0
/ self.dt
* (
lg1(0.1, random_point + self.dt * random_direction)
- lg1(0.1, random_point - self.dt * random_direction)
)
)
self.assertAllClose(
lg1.jacobian(0.1, random_point) @ random_direction,
fd_approx,
rtol=self.rtol,
)
def test_lorenz_jacobian(self):
rv = Constant(np.array([1.0, 1.0, 1.0]))
lg1 = ivp_examples.lorenz(self.tspan, rv)
random_direction = 1 + 0.1 * np.random.rand(lg1.dimension)
random_point = 1 + np.random.rand(lg1.dimension)
fd_approx = (
0.5
* 1.0
/ self.dt
* (
lg1(0.1, random_point + self.dt * random_direction)
- lg1(0.1, random_point - self.dt * random_direction)
)
)
self.assertAllClose(
lg1.jacobian(0.1, random_point) @ random_direction,
fd_approx,
rtol=self.rtol,
)
def test_lotkavolterra_rhs(self):
rv = Constant(np.ones(2))
lg1 = ivp_examples.lotkavolterra(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def test_fitzhughnagumo_rhs(self):
rv = Constant(np.ones(2))
lg1 = ivp_examples.fitzhughnagumo(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def test_logistic_rhs(self):
rv = Constant(0.1)
lg1 = ivp_examples.logistic(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def setUp(self):
initrv = Constant(20 * np.ones(2))
self.ivp = lotkavolterra([0.0, 0.5], initrv)
step = 0.1
self.solution = probsolve_ivp(self.ivp, which_prior="ibm3", step=step)
def test_lorenz_rhs(self):
rv = Constant(np.ones(3))
lg1 = ivp_examples.lorenz(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def setUp(self):
"""Setup odesolver and solve a scalar ode."""
initrv = Constant(0.1 * np.ones(1))
self.ivp = ode.logistic([0.0, 1.5], initrv)
self.stps = [0.2, 0.1]
def load_lotkavolterra():
"""Load LV system as a basic IVP."""
initrv = Constant(np.array([20, 20]))
return lotkavolterra(timespan=[0, 0.55],
initrv=initrv,
params=(0.5, 0.05, 0.5, 0.05))
def ivp():
initrv = Constant(20.0 * np.ones(2))
return ode.lotkavolterra([0.0, 0.25], initrv)
def setUp(self):
self.rv_list = _RandomVariableList([Constant(0.1), Constant(0.2)])
def test_vanderpol_rhs(self):
rv = Constant(np.ones(2))
lg1 = ivp_examples.vanderpol(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def test_threebody_rhs(self):
rv = Constant(np.ones(4))
lg1 = ivp_examples.threebody(self.tspan, rv)
self.assertEqual(lg1.rhs(0.1, rv).shape, rv.shape)
def setUp(self):
"""Setup odesolver and solve a scalar ode."""
initrv = Constant(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 0.5], initrv)
self.tol = 1e-2
def test_rigidbody(self):
"""Test the rigidbody ODE convenience function."""
rv = Constant(np.array([1.0, 1.0, 1.0]))
lg1 = ivp_examples.rigidbody(self.tspan, rv)
self.assertIsInstance(lg1, ivp.IVP)
def setUp(self):
"""Setup odesolver and Lotka-Volterra IVP."""
initdist = Constant(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 0.5], initdist)
self.tol = 1e-1
self.step = 0.1
def setUp(self):
initrv = Constant(0.1 * np.ones(1))
self.ivp = logistic([0.0, 1.5], initrv)
step = 0.1
self.solution = probsolve_ivp(self.ivp, which_prior="ibm3", step=step)
def setUp(self):
initdist = Constant(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 1e-4], initdist)
self.step = 1e-5
self.prior = "ibm3"
def ivp():
initrv = Constant(0.1 * np.ones(1))
return ode.logistic([0.0, 1.5], initrv)
def setUp(self):
y0 = Constant(0.3)
ivp = logistic([0, 4], initrv=y0)
euler_order = 1
self.solver = MockODESolver(ivp, order=euler_order)
self.step = 0.2
