def test_default_call_EMD():
T = np.arange(50)
S = np.cos(T * 0.1)
max_imf = 2
emd = emd()
emd(S, T, max_imf)
def test_emd_passArgsViaDict(self):
FIXE = 10
params = {"FIXE": FIXE, "nothing": 0}
# First test without initiation
emd = emd()
self.assertFalse(emd.FIXE == FIXE, "{} == {}".format(emd.FIXE, FIXE))
# Second: test with passing
emd = emd(**params)
self.assertTrue(emd.FIXE == FIXE, "{} == {}".format(emd.FIXE, FIXE))
def test_imfs_and_residue_accessor(self):
S = np.random.random(200)
emd = emd(**{"MAX_ITERATION": 10, "FIXE": 20})
all_imfs = emd(S, max_imf=3)
imfs, residue = emd.get_imfs_and_residue()
self.assertEqual(all_imfs.shape[0], imfs.shape[0] + 1,
"Compare number of components")
self.assertTrue(np.array_equal(all_imfs[:-1], imfs),
"Shouldn't matter where imfs are from")
self.assertTrue(np.array_equal(all_imfs[-1], residue),
"Residue, if any, is the last row")
def test_emd_FIXE(self):
T = np.linspace(0, 1, 100)
c = np.sin(9 * 2 * np.pi * T)
offset = 4
S = c + offset
emd = emd()
# Default state: converge
self.assertTrue(emd.FIXE == 0)
self.assertTrue(emd.FIXE_H == 0)
# Set 1 iteration per each sift,
# same as removing offset
FIXE = 1
emd.FIXE = FIXE
# Check flags correctness
self.assertTrue(emd.FIXE == FIXE)
self.assertTrue(emd.FIXE_H == 0)
# Extract IMFs
IMFs = emd.emd(S)
# Check that IMFs are correct
self.assertTrue(np.allclose(IMFs[0], c))
self.assertTrue(np.allclose(IMFs[1], offset))
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_different_length_input(self):
T = np.arange(20)
S = np.random.random(len(T) + 7)
emd = emd()
with self.assertRaises(ValueError):
emd.emd(S, T)
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_unsupporter_spline(self):
emd = emd()
emd.spline_kind = "waterfall"
S = np.random.random(20)
with self.assertRaises(ValueError):
emd.emd(S)
def test_wrong_extrema_detection_type(self):
emd = emd()
emd.extrema_detection = "very_complicated"
t = np.arange(10)
s = np.array([-1, 0, 1, 0, -1, 0, 3, 0, -9, 0])
with self.assertRaises(ValueError):
find_extrema(t, s)
def test_max_iteration_flag(self):
S = np.random.random(200)
emd = emd()
emd.MAX_ITERATION = 10
emd.FIXE = 20
imfs = emd.emd(S)
# There's not much to test, except that it doesn't fail.
# With low MAX_ITERATION value for random signal it's
# guaranteed to have at least 2 imfs.
self.assertTrue(imfs.shape[0] > 1)
def test_trend(self):
"""
Input is trend. Expeting no shifting process.
"""
emd = emd()
t = np.arange(0, 1, 0.01)
S = 2 * t
# Input - linear function f(t) = 2*t
imfs = emd.emd(S, t)
self.assertEqual(imfs.shape[0], 1, "Expecting single IMF")
self.assertTrue(np.allclose(S, imfs[0]))
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_ceemdan_passingCustomEMD(self):
spline_kind = "linear"
params = {"spline_kind": spline_kind}
ceemdan = ceemdan()
self.assertFalse(ceemdan.EMD.spline_kind==spline_kind,
"Not"+self.cmp_msg(ceemdan.EMD.spline_kind, spline_kind))
from EMD import emd
emd = emd(**params)
ceemdan = ceemdan(ext_EMD=emd)
self.assertTrue(ceemdan.EMD.spline_kind==spline_kind,
self.cmp_msg(ceemdan.EMD.spline_kind, spline_kind))
def __init__(self,
trials=100,
epsilon=0.005,
ext_EMD=None,
parallel=True,
**config):
"""
Configuration can be passed through config dictionary.
For example, updating threshold would be through:
# >>> config = {"range_thr": 0.001, "total_power_thr": 0.01}
# >>> EMD = EMD(**config)
"""
# Ensemble constants
self.trials = trials
self.epsilon = epsilon
self.all_noise_std = np.zeros(self.trials)
self.beta_progress = True # Scale noise by std
self.random = np.random.RandomState()
self.noise_kind = "normal"
self.parallel = parallel
self.all_noise_EMD = []
if ext_EMD is None:
from EMD import emd
self.EMD = emd()
else:
self.EMD = ext_EMD
self.range_thr = 0.01
self.total_power_thr = 0.05
# By default (None) Pool spawns #processes = #CPU
if parallel:
processes = None if "processes" not in config else config[
"processes"]
self.pool = Pool(processes=processes)
# Update based on options
for key in config.keys():
if key in self.__dict__.keys():
self.__dict__[key] = config[key]
elif key in self.EMD.__dict__.keys():
self.EMD.__dict__[key] = config[key]
def test_eemd_passingCustomEMD(self):
spline_kind = "linear"
params = {"spline_kind": spline_kind}
eemd = eemd()
self.assertFalse(
eemd.EMD.spline_kind == spline_kind,
"Not" + self.cmp_msg(eemd.EMD.spline_kind, spline_kind))
from EMD import emd
emd = emd(**params)
eemd = eemd(ext_EMD=emd)
self.assertTrue(eemd.EMD.spline_kind == spline_kind,
self.cmp_msg(eemd.EMD.spline_kind, spline_kind))
def test_emd_default(self):
T = np.linspace(0, 2, 200)
c1 = 1 * np.sin(11 * 2 * np.pi * T + 0.1)
c2 = 11 * np.sin(1 * 2 * np.pi * T + 0.1)
offset = 9
S = c1 + c2 + offset
emd = emd(spline_kind='akima')
imfs = emd.emd(S, T)
self.assertTrue(imfs.shape[0] == 3)
close_imfs1 = np.allclose(c1[2:-2], imfs[0, 2:-2], atol=0.21)
self.assertTrue(close_imfs1)
close_imfs2 = np.allclose(c2[2:-2], imfs[1, 2:-2], atol=0.24)
diff = np.abs(c2[2:-2] - imfs[1, 2:-2])
self.assertTrue(close_imfs2)
close_offset = np.allclose(offset, imfs[2, 1:-1], atol=0.5)
self.assertTrue(close_offset)
def test_find_extrema_parabol(self):
"""
Simple test for extrema.
"""
emd = emd()
emd.extrema_detection = "parabol"
t = np.arange(10)
s = np.array([-1, 0, 1, 0, -1, 0, 3, 0, -9, 0])
expMaxPos = [2, 6]
expMaxVal = [1, 3]
expMinPos = [4, 8]
expMinVal = [-1, -9]
maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s)
self.assertEqual(maxPos.tolist(), expMaxPos)
self.assertEqual(maxVal.tolist(), expMaxVal)
self.assertEqual(minPos.tolist(), expMinPos)
self.assertEqual(minVal.tolist(), expMinVal)
def test_incorrectExtremaDetectionSetup(self):
extrema_detection = "bubble_gum"
# Sanity check
emd = emd()
self.assertFalse(emd.extrema_detection == extrema_detection)
# Assign incorrect extrema_detection
emd.extrema_detection = extrema_detection
self.assertTrue(emd.extrema_detection == extrema_detection)
T = np.arange(10)
S = np.sin(T)
max_pos, max_val = np.random.random((2, 3))
min_pos, min_val = np.random.random((2, 3))
# Check for Exception
with self.assertRaises(ValueError):
emd.mirror_extension_prepare_points(T, S, max_pos, max_val,
min_pos, min_val)
def test_find_extrema_simple_repeat(self):
"""
Test what happens in /^^\ situation, i.e.
when extremum is somewhere between two consecutive pts.
"""
emd = emd()
emd.extrema_detection = "simple"
t = np.arange(2, 13)
s = np.array([-1, 0, 1, 1, 0, -1, 0, 3, 0, -9, 0])
expMaxPos = [4, 9]
expMaxVal = [1, 3]
expMinPos = [7, 11]
expMinVal = [-1, -9]
maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s)
self.assertEqual(maxPos.tolist(), expMaxPos)
self.assertEqual(maxVal.tolist(), expMaxVal)
self.assertEqual(minPos.tolist(), expMinPos)
self.assertEqual(minVal.tolist(), expMinVal)
def test_emd_FIXEH(self):
T = np.linspace(0, 2, 200)
c1 = 1 * np.sin(11 * 2 * np.pi * T + 0.1)
c2 = 11 * np.sin(1 * 2 * np.pi * T + 0.1)
offset = 9
S = c1 + c2 + offset
emd = emd()
# Default state: converge
self.assertTrue(emd.FIXE == 0)
self.assertTrue(emd.FIXE_H == 0)
# Set 5 iterations per each protoIMF
FIXE_H = 6
emd.FIXE_H = FIXE_H
# Check flags correctness
self.assertTrue(emd.FIXE == 0)
self.assertTrue(emd.FIXE_H == FIXE_H)
# Extract IMFs
imfs = emd.emd(S)
# Check that IMFs are correct
self.assertTrue(imfs.shape[0] == 3)
close_imf1 = np.allclose(c1[2:-2], imfs[0, 2:-2], atol=0.2)
self.assertTrue(close_imf1)
self.assertTrue(np.allclose(c1, imfs[0], atol=1.))
close_imf2 = np.allclose(c2[2:-2], imfs[1, 2:-2], atol=0.21)
self.assertTrue(close_imf2)
self.assertTrue(np.allclose(c2, imfs[1], atol=1.))
close_offset = np.allclose(offset, imfs[2, 2:-2], atol=0.1)
self.assertTrue(close_offset)
close_offset = np.allclose(offset, imfs[2, 1:-1], atol=0.5)
self.assertTrue(close_offset)
def test_single_imf(self):
"""
Input is IMF. Expecint single shifting.
"""
max_diff = lambda a, b: np.max(np.abs(a - b))
emd = emd()
emd.FIXE_H = 2
t = np.arange(0, 1, 0.001)
c1 = np.cos(4 * 2 * np.pi * t) # 2 Hz
S = c1.copy()
# Input - linear function f(t) = sin(2Hz t)
# import pdb; pdb.set_trace()
imfs = emd.emd(S, t)
self.assertEqual(imfs.shape[0], 1, "Expecting sin + trend")
diff = np.allclose(imfs[0], c1)
self.assertTrue(
diff, "Expecting 1st IMF to be sin\nMaxDiff = " +
str(max_diff(imfs[0], c1)))
# Input - linear function f(t) = siin(2Hz t) + 2*t
c2 = 5 * (t + 2)
S += c2.copy()
imfs = emd.emd(S, t)
self.assertEqual(imfs.shape[0], 2, "Expecting sin + trend")
diff1 = np.allclose(imfs[0], c1, atol=0.2)
self.assertTrue(
diff1, "Expecting 1st IMF to be sin\nMaxDiff = " +
str(max_diff(imfs[0], c1)))
diff2 = np.allclose(imfs[1], c2, atol=0.2)
self.assertTrue(
diff2, "Expecting 2nd IMF to be trend\nMaxDiff = " +
str(max_diff(imfs[1], c2)))
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.mirror_extension_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 = 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 = 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 = 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 = 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.mirror_extension_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 = 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 = 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 = 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 = 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())
# Author: Dawid Laszuk
# Last update: 7/07/2017
from __future__ import division, print_function
import numpy as np
import pylab as plt
from EMD import emd
# Define signal
t = np.linspace(0, 1, 200)
s = np.cos(11 * 2 * np.pi * t * t) + 6 * t * t
# Execute EMD on signal
IMF = emd().emd(s, t)
N = IMF.shape[0] + 1
# Plot results
plt.subplot(N, 1, 1)
plt.plot(t, s, 'r')
plt.title("Input signal: $S(t)=cos(22\pi t^2) + 6t^2$")
plt.xlabel("Time [s]")
for n, imf in enumerate(IMF):
plt.subplot(N, 1, n + 2)
plt.plot(t, imf, 'g')
plt.title("IMF " + str(n + 1))
plt.xlabel("Time [s]")
plt.tight_layout()
plt.savefig('simple_example')
plt.show()
return phase
# Define signal
t = np.linspace(0, 1, 200)
dt = t[1] - t[0]
sin = lambda x, p: np.sin(2 * np.pi * x * t + p)
S = 3 * sin(18, 0.2) * (t - 0.2)**2
S += 5 * sin(11, 2.7)
S += 3 * sin(14, 1.6)
S += 1 * np.sin(4 * 2 * np.pi * (t - 0.8)**2)
S += t**2.1 - t
# Compute IMFs with EMD
emd = emd()
imfs = emd(S, t)
# Extract instantaneous phases and frequencies using Hilbert transform
instant_phases = instant_phase(imfs)
instant_freqs = np.diff(instant_phases) / (2 * np.pi * dt)
# Create a figure consisting of 3 panels which from the top are the input signal, IMFs and instantaneous frequencies
fig, axes = plt.subplots(3, figsize=(12, 12))
# The top panel shows the input signal
ax = axes[0]
ax.plot(t, S)
ax.set_ylabel("Amplitude [arb. u.]")
ax.set_title("Input signal")
filename = "s" + str(j + 1) + ".dat"
s = open(process_name1 + filename, "rb") # 以bytes类型正常读取文件
print(process_name + filename)
num = pickle.load(s, encoding="latin1")
labels = num['labels']
num_list_Theta = numpy.zeros((32, 2560))
num_list_Alpha = numpy.zeros((32, 2560))
num_list_Beta = numpy.zeros((32, 2560))
num_list_Gamma = numpy.zeros((32, 2560))
for p in range(0, 32):
Theta = num['Theta'][p]
Alpha = num['Alpha'][p]
Beta = num['Beta'][p]
Gamma = num['Gamma'][p]
imf1_Theta = emd(Theta)
print(1)
imf1_Alpha = emd(Alpha)
print(2)
imf1_Beta = emd(Beta)
print(3)
imf1_Gamma = emd(Gamma)
print(4)
for m in range(0, 2560):
for n in range(1, len(imf1_Theta)):
imf1_Theta[0][m] += imf1_Theta[n][m]
print('Theta' + str(p))
for n in range(1, len(imf1_Alpha)):
imf1_Alpha[0][m] += imf1_Alpha[n][m]
print('Alpha' + str(p))
for n in range(1, len(imf1_Beta)):
