def test_comparison(self):
interval = (-3, 10)
t = symengine.Symbol("t")
spline = CubicHermiteSpline(n=2)
spline.from_function(
[symengine.sin(t), symengine.cos(t)],
times_of_interest=interval,
max_anchors=100,
)
times = np.linspace(*interval, 100)
evaluation = spline.get_state(times)
control = np.vstack((np.sin(times), np.cos(times))).T
assert_allclose(evaluation, control, atol=0.01)
def as_cubic_splines(self, duration, dt):
"""
Return as cubic Hermite splines after checking stimulus bounds.
"""
self._get_times(duration, dt)
stim_input = self._trim_stim_input(self.generate_input(duration, dt))
return CubicHermiteSpline.from_data(self.times, stim_input)
def as_cubic_splines(self):
"""
Return as cubic Hermite splines after checking stimulus bounds.
"""
stim_input = self.generate_input()
stim_input[self.times < self.stim_start] = 0.0
stim_input[self.times > self.stim_end] = 0.0
return CubicHermiteSpline.from_data(self.times, stim_input)
def test_arbitrary_anchors(self):
n = 100
spline = CubicHermiteSpline(
n, [(time, np.random.normal(0, 1, n), np.random.normal(0, 0.1, n))
for time in sorted(np.random.uniform(-10, 10, 2))])
times = np.linspace(spline[0].time, spline[1].time, 10000)
values = np.vstack([spline.get_recent_state(time) for time in times])
result = extrema_from_anchors(spline[-2:])
assert_allclose(result.minima, np.min(values, axis=0), atol=1e-3)
assert_allclose(result.maxima, np.max(values, axis=0), atol=1e-3)
assert_allclose(result.arg_min,
times[np.argmin(values, axis=0)],
atol=1e-3)
assert_allclose(result.arg_max,
times[np.argmax(values, axis=0)],
atol=1e-3)
def setUp(self):
interval = (-3, 2)
self.times = np.linspace(*interval, 10)
t = symengine.Symbol("t")
self.sin_spline = CubicHermiteSpline(n=1)
self.sin_spline.from_function(
[symengine.sin(t)],
times_of_interest=interval,
max_anchors=100,
)
self.sin_evaluation = self.sin_spline.get_state(self.times)
self.exp_spline = CubicHermiteSpline(n=1)
self.exp_spline.from_function(
[symengine.exp(t)],
times_of_interest=interval,
max_anchors=100,
)
self.exp_evaluation = self.exp_spline.get_state(self.times)
def as_cubic_splines(self, duration, dt):
"""
Return as cubic Hermite splines.
:param duration: duration of the input, in miliseconds
:type duration: float
:param dt: some reasonable "speed" of input, in miliseconds
:type dt: float
"""
self._get_times(duration, dt)
return CubicHermiteSpline.from_data(self.times, self.generate_input(duration, dt))
def test_simple_polynomial(self):
T = symengine.Symbol("T")
poly = 2 * T**3 - 3 * T**2 - 36 * T + 17
arg_extremes = [-2, 3]
arrify = lambda expr, t: np.atleast_1d(float(expr.subs({T: t})))
spline = CubicHermiteSpline(
1, [(t, arrify(poly, t), arrify(poly.diff(T), t))
for t in arg_extremes])
result = extrema_from_anchors(spline)
assert_allclose(result.minima, arrify(poly, arg_extremes[1]))
assert_allclose(result.maxima, arrify(poly, arg_extremes[0]))
assert_allclose(result.arg_min, arg_extremes[1])
assert_allclose(result.arg_max, arg_extremes[0])
def test_given_extrema(self):
n = 100
positions = sorted(np.random.random(2))
state = np.random.random(n)
spline = CubicHermiteSpline(n, [
(positions[0], state, np.zeros(n)),
(positions[1], state + np.random.uniform(0, 5), np.zeros(n)),
])
result = extrema_from_anchors(spline)
assert_allclose(result.arg_min, spline[0].time)
assert_allclose(result.arg_max, spline[1].time)
assert_allclose(result.minima, spline[0][1])
assert_allclose(result.maxima, spline[1][1])
def test_multiple_anchors(self):
for _ in range(10):
n = 100
spline = CubicHermiteSpline(
n,
[(time, np.random.normal(0, 1, n), np.random.normal(0, 0.1, n))
for time in sorted(np.random.uniform(-10, 10, 3))])
beginning, end = sorted(
np.random.uniform(spline[0].time, spline[-1].time, 2))
times = np.linspace(beginning, end, 10000)
values = np.vstack([spline.get_state(time) for time in times])
result = spline.extrema(beginning, end)
assert_allclose(result.minima, np.min(values, axis=0), atol=1e-3)
assert_allclose(result.maxima, np.max(values, axis=0), atol=1e-3)
assert_allclose(result.arg_min,
times[np.argmin(values, axis=0)],
atol=1e-3)
assert_allclose(result.arg_max,
times[np.argmax(values, axis=0)],
atol=1e-3)
class TestAdditions(unittest.TestCase):
def setUp(self):
interval = (-3, 2)
self.times = np.linspace(*interval, 10)
t = symengine.Symbol("t")
self.sin_spline = CubicHermiteSpline(n=1)
self.sin_spline.from_function(
[symengine.sin(t)],
times_of_interest=interval,
max_anchors=100,
)
self.sin_evaluation = self.sin_spline.get_state(self.times)
self.exp_spline = CubicHermiteSpline(n=1)
self.exp_spline.from_function(
[symengine.exp(t)],
times_of_interest=interval,
max_anchors=100,
)
self.exp_evaluation = self.exp_spline.get_state(self.times)
def has_matched_times(self, spline):
self.assertSetEqual(
set(self.sin_spline.times) | set(self.exp_spline.times),
set(spline.times),
)
def test_plus(self):
combined = self.sin_spline.copy()
combined.plus(self.exp_spline)
evaluation = combined.get_state(self.times)
control = np.atleast_2d(np.sin(self.times) + np.exp(self.times)).T
control_2 = self.sin_evaluation + self.exp_evaluation
self.has_matched_times(combined)
assert_allclose(control, control_2, atol=0.01)
assert_allclose(evaluation, control, atol=0.01)
def test_join(self):
joined = join(self.sin_spline, self.exp_spline)
evaluation = joined.get_state(self.times)
evaluation = joined.get_state(self.times)
control = np.vstack((np.sin(self.times), np.exp(self.times))).T
control_2 = np.hstack((self.sin_evaluation, self.exp_evaluation))
self.has_matched_times(joined)
assert_allclose(control, control_2, atol=0.01)
assert_allclose(evaluation, control, atol=0.01)
def test_random_function(self):
roots = np.sort(np.random.normal(size=5))
value = np.random.normal()
t = symengine.Symbol("t")
function = np.prod([t - root for root in roots]) + value
i = 1
spline = CubicHermiteSpline(n=3)
spline.from_function(
[10, function, 10],
times_of_interest=(min(roots) - 0.01, max(roots) + 0.01),
max_anchors=1000,
tol=7,
)
solutions = spline.solve(i=i, value=value)
sol_times = [sol[0] for sol in solutions]
assert_allclose(spline.get_state(sol_times)[:, i], value)
assert_allclose([sol[0] for sol in solutions], roots, atol=1e-3)
for time, diff in solutions:
true_diff = float(function.diff(t).subs({t: time}))
self.assertAlmostEqual(true_diff, diff, places=5)
def test_wrong_shape(self):
with self.assertRaises(ValueError):
CubicHermiteSpline(1, [(1, [2, 3], [4, 5])])
atol=atol,
rtol=rtol)
t = sol.t
y = sol.y[0, :]
yp = sol.yp[0, :]
# #jitcdde
from symengine import exp
ts = [1 - c, 1, 2 - c, tf]
fs = [[-r * y_jit(0) * 0.4 * (1 - t_jit)],
[-r * y_jit(0) * (0.4 * (1 - t_jit) + 10.0 - exp(mu) * y_jit(0))],
[-r * y_jit(0) * (10. - exp(mu) * y_jit(0))],
[-r * exp(mu) * y_jit(0) * (y_jit(0, t_jit - tau) - y_jit(0))]]
from chspy import CubicHermiteSpline
histo = CubicHermiteSpline(n=1)
histo.constant(y0)
print(ts)
y_jit = []
dt_jit = []
t_jit = []
for target_time, f in zip(ts, fs):
DDE = jitcdde(f, max_delay=tau)
DDE.set_integration_parameters(atol=atol, rtol=rtol)
DDE.add_past_points(histo)
DDE.adjust_diff()
for ti in np.linspace(DDE.t, target_time, 100):
t_jit.append(ti)
y_jit.append(DDE.integrate(ti)[0])
dt_jit.append(DDE.dt)
def as_cubic_splines(self):
"""
Return as cubic Hermite splines.
"""
return CubicHermiteSpline.from_data(self.times, self.generate_input())
def test_replace_with_same(self):
spline = CubicHermiteSpline(1, [(0, [0], [0])])
spline[-1] = (0, [1], [2])
def test_wrong_time(self):
with self.assertRaises(ValueError):
CubicHermiteSpline(1, [(0, [0], [0]), (0, [1], [2])])
def test_wrong_diff_shape(self):
with self.assertRaises(ValueError):
CubicHermiteSpline(1, [(1, [2], [3, 4])])
from chspy import CubicHermiteSpline
from matplotlib.pyplot import subplots
spline = CubicHermiteSpline(n=3)
# time state slope
spline.add((0, [1, 3, 0], [0, 1, 0]))
spline.add((1, [3, 2, 0], [0, 4, 0]))
spline.add((4, [0, 1, 3], [0, 4, 0]))
fig, axes = subplots(figsize=(7, 2))
spline.plot(axes)
axes.set_xlabel("time")
axes.set_ylabel("state")
fig.legend(loc="right", labelspacing=1)
fig.subplots_adjust(right=0.7)
lambda x, j=j: sum(np.arange(1, 4) * coeff[j, 1:] * (x**np.arange(3)))
for j in range(m)
]
assert poly[0](1.0) != poly[1](1.0)
assert diff[0](1.0) != diff[1](1.0)
spline = CubicHermiteSpline(m, [
(
0.0,
np.array([poly[j](0.0) for j in range(m)]),
np.array([diff[j](0.0) for j in range(m)]),
),
(
0.5,
np.array([poly[j](0.5) for j in range(m)]),
np.array([diff[j](0.5) for j in range(m)]),
),
(
2.0,
np.random.random(m),
np.random.random(m),
),
])
class interpolation_test(unittest.TestCase):
def test_anchors(self):
for s in range(len(spline) - 1):
t = spline[s][0]
anchors = (spline[s], spline[s + 1])