def test_cubic(self):
dtype = np.float64
emd = EMD()
emd.spline_kind = 'cubic'
emd.DTYPE = dtype
T = np.array([0, 1, 2, 3, 4], dtype=dtype)
S = np.array([0, 1, -1, -1, 5], dtype=dtype)
t = np.arange(9, dtype=dtype) / 2.
# TODO: Something weird with float32.
# Seems to be SciPy problem.
_t, s = emd.spline_points(t, np.array((T, S)))
s_true = np.array([S[0], 1.203125, S[1], 0.046875, \
S[2], -1.515625, S[3], 1.015625, S[4]], dtype=dtype)
self.assertTrue(np.allclose(s, s_true), "Comparing cubic")
T = T[:-2].copy()
S = S[:-2].copy()
t = np.arange(5, dtype=dtype) / 2.
_t, s3 = emd.spline_points(t, np.array((T, S)))
s3_true = np.array([S[0], 0.78125, S[1], 0.28125, S[2]], dtype=dtype)
self.assertTrue(np.allclose(s3, s3_true), "Compare cubic 3pts")
def test_akima(self):
dtype = np.float32
emd = EMD()
emd.spline_kind = 'akima'
emd.DTYPE = dtype
arr = lambda x: np.array(x)
# Test error: len(X)!=len(Y)
with self.assertRaises(ValueError):
akima(arr([0]), arr([1, 2]), arr([0, 1, 2]))
# Test error: any(dt) <= 0
with self.assertRaises(ValueError):
akima(arr([1, 0, 2]), arr([1, 2]), arr([0, 1, 2]))
with self.assertRaises(ValueError):
akima(arr([0, 0, 2]), arr([1, 2]), arr([0, 1, 1]))
# Test for correct responses
T = np.array([0, 1, 2, 3, 4], dtype)
S = np.array([0, 1, -1, -1, 5], dtype)
t = np.array([i / 2. for i in range(9)], dtype)
_t, s = emd.spline_points(t, np.array((T, S)))
s_true = np.array([
S[0], 0.9125, S[1], 0.066666, S[2], -1.35416667, S[3], 1.0625, S[4]
], dtype)
self.assertTrue(np.allclose(s_true, s), "Comparing akima with true")
s_np = akima(np.array(T), np.array(S), np.array(t))
self.assertTrue(np.allclose(s, s_np), "Shouldn't matter if with numpy")
def test_cubic(self):
dtype = np.float64
emd = EMD()
emd.spline_kind = 'cubic'
emd.DTYPE = dtype
T = np.array([0, 1, 2, 3, 4], dtype=dtype)
S = np.array([0, 1, -1, -1, 5], dtype=dtype)
t = np.arange(9, dtype=dtype)/2.
# TODO: Something weird with float32.
# Seems to be SciPy problem.
_t, s = emd.spline_points(t, np.array((T,S)))
s_true = np.array([S[0], 1.203125, S[1], 0.046875, \
S[2], -1.515625, S[3], 1.015625, S[4]], dtype=dtype)
self.assertTrue(np.allclose(s, s_true, atol=0.01), "Comparing cubic")
T = T[:-2].copy()
S = S[:-2].copy()
t = np.arange(5, dtype=dtype)/2.
_t, s3 = emd.spline_points(t, np.array((T,S)))
s3_true = np.array([S[0], 0.78125, S[1], 0.28125, S[2]], dtype=dtype)
self.assertTrue(np.allclose(s3, s3_true), "Compare cubic 3pts")
def test_akima(self):
dtype = np.float32
emd = EMD()
emd.spline_kind = 'akima'
emd.DTYPE = dtype
# Test error: len(X)!=len(Y)
with self.assertRaises(ValueError):
akima(np.array([0]), np.array([1,2]), np.array([0,1,2]))
# Test error: any(dt) <= 0
with self.assertRaises(ValueError):
akima(np.array([1,0,2]), np.array([1,2]), np.array([0,1,2]))
with self.assertRaises(ValueError):
akima(np.array([0,0,2]), np.array([1,2]), np.array([0,1,1]))
# Test for correct responses
T = np.array([0, 1, 2, 3, 4], dtype)
S = np.array([0, 1, -1, -1, 5], dtype)
t = np.array([i/2. for i in range(9)], dtype)
_t, s = emd.spline_points(t, np.array((T,S)))
s_true = np.array([S[0], 0.9125, S[1], 0.066666,
S[2],-1.35416667, S[3], 1.0625, S[4]], dtype)
self.assertTrue(np.allclose(s_true, s), "Comparing akima with true")
s_np = akima(np.array(T), np.array(S), np.array(t))
self.assertTrue(np.allclose(s, s_np), "Shouldn't matter if with numpy")
def test_slinear(self):
dtype = np.float64
emd = EMD()
emd.spline_kind = 'slinear'
emd.DTYPE = dtype
T = np.array([0, 1, 2, 3, 4], dtype=dtype)
S = np.array([0, 1, -1, -1, 5], dtype=dtype)
t = np.arange(9, dtype=dtype) / 2.
_t, s = emd.spline_points(t, np.array((T, S)))
s_true = np.array([S[0], 0.5, S[1], 0, \
S[2], -1, S[3], 2, S[4]], dtype=dtype)
self.assertTrue(np.allclose(s, s_true), "Comparing SLinear")
def test_slinear(self):
dtype = np.float64
emd = EMD()
emd.spline_kind = 'slinear'
emd.DTYPE = dtype
T = np.array([0, 1, 2, 3, 4], dtype=dtype)
S = np.array([0, 1, -1, -1, 5], dtype=dtype)
t = np.arange(9, dtype=dtype)/2.
_t, s = emd.spline_points(t, np.array((T,S)))
s_true = np.array([S[0], 0.5, S[1], 0, \
S[2], -1, S[3], 2, S[4]], dtype=dtype)
self.assertTrue(np.allclose(s, s_true), "Comparing SLinear")
def test_bound_extrapolation_simple(self):
emd = EMD()
emd.extrema_detection = "simple"
emd.nbsym = 1
emd.DTYPE = np.int64
S = [0, -3, 1, 4, 3, 2, -2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0, -2, -1]
S = np.array(S)
T = np.arange(len(S))
pp = emd.prepare_points
# There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound:
# L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max)
# L2) / -- ext[0] is min, s[0] > ext[1] (1st max)
# L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min)
# L4) \ -- ext[0] is max, s[0] < ext[1] (1st min)
## CASE 1
# L1, R1 -- no edge MIN & no edge MIN
s = S.copy()
t = T.copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-1, 3, 9, 14, 20], maxExtrema[0].tolist())
self.assertEqual([4, 4, 2, 5, 5], maxExtrema[1].tolist())
self.assertEqual([-4, 1, 6, 11, 17, 23], minExtrema[0].tolist())
self.assertEqual([-2, -3, -2, 0, -2, 0], minExtrema[1].tolist())
## CASE 2
# L2, R2 -- edge MIN, edge MIN
s = S[1:-1].copy()
t = np.arange(s.size)
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-2, 2, 8, 13, 19], maxExtrema[0].tolist())
self.assertEqual([4, 4, 2, 5, 5], maxExtrema[1].tolist())
self.assertEqual([0, 5, 10, 16], minExtrema[0].tolist())
self.assertEqual([-3, -2, 0, -2], minExtrema[1].tolist())
## CASE 3
# L3, R3 -- no edge MAX & no edge MAX
s = S[2:-3].copy()
t = np.arange(s.size)
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-5, 1, 7, 12, 17], maxExtrema[0].tolist())
self.assertEqual([2, 4, 2, 5, 2], maxExtrema[1].tolist())
self.assertEqual([-2, 4, 9, 15], minExtrema[0].tolist())
self.assertEqual([-2, -2, 0, 0], minExtrema[1].tolist())
## CASE 4
# L4, R4 -- edge MAX & edge MAX
s = S[3:-4].copy()
t = np.arange(s.size)
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([0, 6, 11], maxExtrema[0].tolist())
self.assertEqual([4, 2, 5], maxExtrema[1].tolist())
self.assertEqual([-3, 3, 8, 14], minExtrema[0].tolist())
self.assertEqual([-2, -2, 0, 0], minExtrema[1].tolist())
def test_bound_extrapolation_parabol(self):
emd = EMD()
emd.extrema_detection = "parabol"
emd.nbsym = 1
emd.DTYPE = np.float64
S = [0, -3, 1, 4, 3, 2, -2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0, -2, -1]
S = np.array(S)
T = np.arange(len(S))
pp = emd.prepare_points
# There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound:
# L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max)
# L2) / -- ext[0] is min, s[0] > ext[1] (1st max)
# L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min)
# L4) \ -- ext[0] is max, s[0] < ext[1] (1st min)
## CASE 1
# L1, R1 -- no edge MIN & no edge MIN
s = S.copy()
t = T.copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-1.393, 3.25, 9, 14.25, 20.083],
maxExtrema[0].tolist())
self.assertEqual([4.125, 4.125, 2, 5.125, 5.125],
maxExtrema[1].tolist())
self.assertEqual([-4.31, 0.929, 6.167, 11, 17.167, 23.333],
minExtrema[0].tolist())
self.assertEqual([-2.083, -3.018, -2.083, 0, -2.042, 0],
minExtrema[1].tolist())
## CASE 2
# L2, R2 -- edge MIN, edge MIN
s = S[1:-1].copy()
t = T[1:-1].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-1.25, 3.25, 9, 14.25, 19.75],
maxExtrema[0].tolist())
self.assertEqual([4.125, 4.125, 2, 5.125, 5.125],
maxExtrema[1].tolist())
self.assertEqual([1, 6.167, 11, 17], minExtrema[0].tolist())
self.assertEqual([-3, -2.083, 0, -2], minExtrema[1].tolist())
## CASE 3
# L3, R3 -- no edge MAX & no edge MAX
s = S[2:-3].copy()
t = T[2:-3].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-2.5, 3.25, 9, 14.25, 19.5], maxExtrema[0].tolist())
self.assertEqual([2, 4.125, 2, 5.125, 2], maxExtrema[1].tolist())
self.assertEqual([0.333, 6.167, 11, 17.5], minExtrema[0].tolist())
self.assertEqual([-2.083, -2.083, 0, 0], minExtrema[1].tolist())
## CASE 4
# L4, R4 -- edge MAX & edge MAX
s = S[3:-4].copy()
t = T[3:-4].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([3, 9, 14], maxExtrema[0].tolist())
self.assertEqual([4, 2, 5], maxExtrema[1].tolist())
self.assertEqual([-0.167, 6.167, 11, 17], minExtrema[0].tolist())
self.assertEqual([-2.083, -2.083, 0, 0], minExtrema[1].tolist())
def test_bound_extrapolation_simple(self):
emd = EMD()
emd.extrema_detection = "simple"
emd.nbsym = 1
emd.DTYPE = np.int64
S = [0,-3, 1, 4, 3, 2,-2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0,-2,-1]
S = np.array(S)
T = np.arange(len(S))
pp = emd.prepare_points
# There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound:
# L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max)
# L2) / -- ext[0] is min, s[0] > ext[1] (1st max)
# L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min)
# L4) \ -- ext[0] is max, s[0] < ext[1] (1st min)
## CASE 1
# L1, R1 -- no edge MIN & no edge MIN
s = S.copy()
t = T.copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-1,3,9,14,20], maxExtrema[0].tolist())
self.assertEqual([4,4,2,5,5], maxExtrema[1].tolist())
self.assertEqual([-4,1,6,11,17,23], minExtrema[0].tolist())
self.assertEqual([-2,-3,-2,0,-2,0], minExtrema[1].tolist())
## CASE 2
# L2, R2 -- edge MIN, edge MIN
s = S[1:-1].copy()
t = T[1:-1].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-1,3,9,14,20], maxExtrema[0].tolist())
self.assertEqual([4,4,2,5,5], maxExtrema[1].tolist())
self.assertEqual([1,6,11,17], minExtrema[0].tolist())
self.assertEqual([-3,-2,0,-2], minExtrema[1].tolist())
## CASE 3
# L3, R3 -- no edge MAX & no edge MAX
s, t = S[2:-3], T[2:-3]
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([-3,3,9,14,19], maxExtrema[0].tolist())
self.assertEqual([2,4,2,5,2], maxExtrema[1].tolist())
self.assertEqual([0,6,11,17], minExtrema[0].tolist())
self.assertEqual([-2,-2,0,0], minExtrema[1].tolist())
## CASE 4
# L4, R4 -- edge MAX & edge MAX
s, t = S[3:-4], T[3:-4]
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
self.assertEqual([3,9,14], maxExtrema[0].tolist())
self.assertEqual([4,2,5], maxExtrema[1].tolist())
self.assertEqual([0,6,11,17], minExtrema[0].tolist())
self.assertEqual([-2,-2,0,0], minExtrema[1].tolist())
def test_bound_extrapolation_parabol(self):
emd = EMD()
emd.extrema_detection = "parabol"
emd.nbsym = 1
emd.DTYPE = np.float64
S = [0,-3, 1, 4, 3, 2,-2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0,-2,-1]
S = np.array(S)
T = np.arange(len(S))
pp = emd.prepare_points
# There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound:
# L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max)
# L2) / -- ext[0] is min, s[0] > ext[1] (1st max)
# L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min)
# L4) \ -- ext[0] is max, s[0] < ext[1] (1st min)
## CASE 1
# L1, R1 -- no edge MIN & no edge MIN
s = S.copy()
t = T.copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-1.393,3.25,9,14.25,20.083], maxExtrema[0].tolist())
self.assertEqual([4.125,4.125,2,5.125,5.125], maxExtrema[1].tolist())
self.assertEqual([-4.31,0.929,6.167,11,17.167,23.333], minExtrema[0].tolist())
self.assertEqual([-2.083,-3.018,-2.083,0,-2.042,0], minExtrema[1].tolist())
## CASE 2
# L2, R2 -- edge MIN, edge MIN
s = S[1:-1].copy()
t = T[1:-1].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-1.25,3.25,9,14.25,19.75], maxExtrema[0].tolist())
self.assertEqual([4.125,4.125,2,5.125,5.125], maxExtrema[1].tolist())
self.assertEqual([1,6.167,11,17], minExtrema[0].tolist())
self.assertEqual([-3,-2.083,0,-2], minExtrema[1].tolist())
## CASE 3
# L3, R3 -- no edge MAX & no edge MAX
s = S[2:-3].copy()
t = T[2:-3].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([-2.5,3.25,9,14.25,19.5], maxExtrema[0].tolist())
self.assertEqual([2,4.125,2,5.125,2], maxExtrema[1].tolist())
self.assertEqual([0.333,6.167,11,17.5], minExtrema[0].tolist())
self.assertEqual([-2.083,-2.083,0,0], minExtrema[1].tolist())
## CASE 4
# L4, R4 -- edge MAX & edge MAX
s = S[3:-4].copy()
t = T[3:-4].copy()
maxPos, maxVal, minPos, minVal, nz = emd.find_extrema(t, s)
# Should extrapolate left and right bounds
maxExtrema, minExtrema = pp(t, s, \
maxPos, maxVal, minPos, minVal)
maxExtrema = np.round(maxExtrema, decimals=3)
minExtrema = np.round(minExtrema, decimals=3)
self.assertEqual([3,9,14], maxExtrema[0].tolist())
self.assertEqual([4,2,5], maxExtrema[1].tolist())
self.assertEqual([-0.167,6.167,11,17], minExtrema[0].tolist())
self.assertEqual([-2.083,-2.083,0,0], minExtrema[1].tolist())
