def test_solve_potts(use_rangemedian):
np.random.seed(1234)
# Easy case, exact solver
y = [1, 1, 1, 2, 2, 2, 3, 3, 3]
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=8.0)
assert right == [9]
assert np.allclose(values, [2], atol=0)
# l1 norm
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
# Bigger case, exact solver
t = np.arange(100)
y0 = (+ 0.4 * (t >= 5)
+ 0.9 * (t >= 10)
- 0.2 * (t >= 20)
+ 0.2 * (t >= 50)
+ 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
right, values, dists = solve_potts(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Bigger case, approximative solver
right, values, dists = solve_potts_approx(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Larger case
t = np.arange(3000)
y0 = (+ 0.4 * (t >= 10)
+ 0.9 * (t >= 30)
- 0.2 * (t >= 200)
+ 0.2 * (t >= 600)
+ 1.1 * (t >= 2500)
- 0.5 * (t >= 2990))
# Small amount of noise shouldn't disturb step finding
y = y0 + 0.05 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [10, 30, 200, 600, 2500, 2990, 3000]
# Large noise should prevent finding any steps
y = y0 + 5.0 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [3000]
# The routine shouldn't choke on datasets with 10k points.
# Appending noisy data to weakly noisy data should retain the
# steps in the former
y = y0 + 0.025 * np.random.rand(y.size)
ypad = 0.025 * np.random.randn(10000 - 3000)
right, values, dists, gamma = solve_potts_autogamma(y.tolist() + ypad.tolist(),
w=[1]*(len(y)+len(ypad)))
assert right == [10, 30, 200, 600, 2500, 2990, 3000, 10000]
def test_solve_potts(use_rangemedian):
np.random.seed(1234)
# Easy case, exact solver
y = [1, 1, 1, 2, 2, 2, 3, 3, 3]
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=8.0)
assert right == [9]
assert np.allclose(values, [2], atol=0)
# l1 norm
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
# Bigger case, exact solver
t = np.arange(100)
y0 = (+ 0.4 * (t >= 5)
+ 0.9 * (t >= 10)
- 0.2 * (t >= 20)
+ 0.2 * (t >= 50)
+ 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
right, values, dists = solve_potts(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Bigger case, approximative solver
right, values, dists = solve_potts_approx(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Larger case
t = np.arange(3000)
y0 = (+ 0.4 * (t >= 10)
+ 0.9 * (t >= 30)
- 0.2 * (t >= 200)
+ 0.2 * (t >= 600)
+ 1.1 * (t >= 2500)
- 0.5 * (t >= 2990))
# Small amount of noise shouldn't disturb step finding
y = y0 + 0.05 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [10, 30, 200, 600, 2500, 2990, 3000]
# Large noise should prevent finding any steps
y = y0 + 5.0 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [3000]
# The routine shouldn't choke on datasets with 10k points.
# Appending noisy data to weakly noisy data should retain the
# steps in the former
y = y0 + 0.025 * np.random.rand(y.size)
ypad = 0.025 * np.random.randn(10000 - 3000)
right, values, dists, gamma = solve_potts_autogamma(y.tolist() + ypad.tolist(),
w=[1]*(len(y)+len(ypad)))
assert right == [10, 30, 200, 600, 2500, 2990, 3000, 10000]
def test_autocorrelated():
# Check that a low-amplitude cosine signal is not interpreted as
# multiple steps
j = np.arange(1000)
y = 0.2 * np.cos(j / 100.0) + 1.0 * (j >= 500)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), p=1)
assert right == [500, 1000]
def test_autocorrelated():
# Check that a low-amplitude cosine signal is not intepreted as
# multiple steps
j = np.arange(1000)
y = 0.2 * np.cos(j/100.0) + 1.0 * (j >= 500)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), p=1)
assert right == [500, 1000]
def test_zero_variance():
# Should not choke on this data
y = [1.0] * 1000
right, values, dists, gamma = solve_potts_autogamma(y, w=[1] * len(y))
assert right == [1000]
def test_zero_variance():
# Should not choke on this data
y = [1.0]*1000
right, values, dists, gamma = solve_potts_autogamma(y, w=[1]*len(y))
assert right == [1000]
