def test_inputs(self):
"""Inputs rejected or accepted according to expected types."""
numpy_array = np.ones(3) * Dirac(0.1)
dirac_list = [Dirac(0.1), Dirac(0.4)]
number_list = [0.5, 0.41]
inputs = [numpy_array, dirac_list, number_list]
inputs_acceptable = [False, True, False]
for inputs, is_acceptable in zip(inputs, inputs_acceptable):
with self.subTest(input=inputs, is_acceptable=is_acceptable):
if is_acceptable:
_RandomVariableList(inputs)
else:
with self.assertRaises(TypeError):
_RandomVariableList(inputs)
def step(self, start, stop, current):
h = stop - start
x = current.mean
xnew = x + h * self.ivp(start, x)
return (
Dirac(xnew),
np.nan,
) # return nan as error estimate to ensure that it is not used
def test_logistic(self):
"""
Test the logistic ODE convenience function.
"""
rv = Dirac(0.1)
lg1 = ivp.logistic(self.tspan, rv)
self.assertEqual(issubclass(type(lg1), ivp.IVP), True)
lg2 = ivp.logistic(self.tspan, rv, params=(1.0, 1.0))
self.assertEqual(issubclass(type(lg2), ivp.IVP), True)
def setUp(self):
initrv = Dirac(0.1 * np.ones(1))
self.ivp = ode.logistic([0.0, 1.5], initrv)
self.step = 0.5
sol = probsolve_ivp(self.ivp,
step=self.step,
diffconst=1.0,
which_prior="ibm1")
state_rvs = sol._state_rvs
self.ms, self.cs = state_rvs.mean, state_rvs.cov
def test_lotkavolterra_jacobian(self):
rv = Dirac(np.ones(2))
lg1 = ivp.lotkavolterra(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 * 1e11 *
(lg1(0.1, random_point + 1e-11 * random_direction) -
lg1(0.1, random_point - 1e-11 * random_direction)))
self.assertAllClose(lg1.jacobian(0.1, random_point) @ random_direction,
fd_approx,
rtol=1e-2)
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 = Dirac(some_center)
self.mockivp = ivp.IVP(
(0.0, np.random.rand()), rv, rhs=rhs_, jac=jac_, sol=sol_
)
def test_fitzhughnagumo_jacobian(self):
rv = Dirac(np.ones(2))
lg1 = ivp.fitzhughnagumo(self.tspan, rv)
random_direction = 1 + 0.1 * np.random.rand(lg1.ndim)
random_point = 1 + np.random.rand(lg1.ndim)
fd_approx = (
0.5
* 1e11
* (
lg1(0.1, random_point + 1e-11 * random_direction)
- lg1(0.1, random_point - 1e-11 * random_direction)
)
)
self.assertAllClose(
lg1.jacobian(0.1, random_point) @ random_direction, fd_approx, rtol=1e-2
)
def test_logistic_jacobian(self):
rv = Dirac(0.1)
lg1 = ivp.logistic(self.tspan, rv)
random_direction = 1 + 0.1 * np.random.rand(lg1.ndim)
random_point = 1 + np.random.rand(lg1.ndim)
fd_approx = (
0.5
* 1e11
* (
lg1(0.1, random_point + 1e-11 * random_direction)
- lg1(0.1, random_point - 1e-11 * random_direction)
)
)
self.assertAllClose(
lg1.jacobian(0.1, random_point) @ random_direction, fd_approx, rtol=1e-2
)
def setUp(self):
self.rv_list = _RandomVariableList([Dirac(0.1), Dirac(0.2)])
def test_lotkavolterra(self):
rv = Dirac(np.ones(2))
lg1 = ivp.lotkavolterra(self.tspan, rv)
lg2 = ivp.lotkavolterra(self.tspan, rv, params=(1.0, 1.0, 1.0, 1.0))
self.assertEqual(issubclass(type(lg2), ivp.IVP), True)
def test_fitzhughnagumo(self):
rv = Dirac(np.ones(2))
lg1 = ivp.fitzhughnagumo(self.tspan, rv)
self.assertEqual(issubclass(type(lg1), ivp.IVP), True)
lg2 = ivp.fitzhughnagumo(self.tspan, rv, params=(1.0, 1.0, 1.0, 1.0))
self.assertEqual(issubclass(type(lg2), ivp.IVP), True)
def load_lotkavolterra():
"""Load LV system as a basic IVP."""
initrv = Dirac(np.array([20, 20]))
return lotkavolterra(timespan=[0, 0.55],
initrv=initrv,
params=(0.5, 0.05, 0.5, 0.05))
def setUp(self):
"""We need a Prior object and an IVP object (with derivatives) to run the tests."""
y0 = Dirac(np.array([20.0, 15.0]))
self.ivp = lotkavolterra([0.4124, 1.15124], y0)
self.prior = IBM(ordint=2, spatialdim=2, diffconst=1.7685)
self.evlvar = 0.0005123121
def setUp(self):
initrv = Dirac(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):
initrv = Dirac(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 setUp(self):
initdist = Dirac(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 1e-4], initdist)
self.step = 1e-5
self.prior = "ibm3"
def setUp(self):
"""Setup odesolver and Lotka-Volterra IVP"""
initdist = Dirac(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 0.5], initdist)
self.tol = 1e-1
self.step = 0.1
def setUp(self):
"""Setup odesolver and solve a scalar ode"""
initrv = Dirac(20 * np.ones(2))
self.ivp = ode.lotkavolterra([0.0, 0.5], initrv)
self.tol = 1e-2
def setUp(self):
"""Setup odesolver and solve a scalar ode"""
initrv = Dirac(0.1 * np.ones(1))
self.ivp = ode.logistic([0.0, 1.5], initrv)
self.stps = [0.2, 0.1]
def setUp(self):
y0 = Dirac(0.3)
ivp = logistic([0, 4], initrv=y0)
self.solver = MockODESolver(ivp)
self.step = 0.2
def setUp(self):
dm = DeterministicModel()
randvar = Dirac(np.ones(TEST_NDIM))
self.samp = dm.sample(0.0, 1.0, 0.01, randvar.mean)