def test_count(self):
list0 = ArrayList('i', 0, 0, 0, 1)
self.assertEqual(list0.count(0), 3)
self.assertEqual(list0.count(1), 1)
self.assertEqual(list0.count(25), 0)
def __init__(self, interactions, n1, alpha, recovery_days, transmission_rate, fatality_rate, initial_setting):
'''
Initialize parameters and objects for COVID-19 simulation
'''
# Constants
self.n = n1
self.ALPHA = alpha
self.RECOVERY_DAYS = recovery_days
self.TRANSMISSION_RATE = transmission_rate
self.FATALITY_RATE = fatality_rate
self.INITIAL_SETTING = initial_setting
self.INTERACTION = interactions
# States
self.CLEAN = 0
self.INFECTED = 1
self.DEAD = 2
self.RECOVERED = 3
# Initialize list
self.Nodes = ArrayList()
for i in range(self.n):
self.Nodes.append(self.Node(i))
# Set random indexes to infected
for v in self.Nodes:
if random.uniform(0,1) <= self.INITIAL_SETTING: # Probability of being infected
v.state = self.INFECTED
v.recover = self.RECOVERY_DAYS
else: # Probability of not being infected
v.state = self.CLEAN
# Initialize graph
self.Graph = self.getInteractionGraph()
def test_index(self):
list0 = ArrayList('i', 0, 0, 0, 1)
self.assertEqual(list0.index(0), 0)
self.assertEqual(list0.index(1), 3)
with self.assertRaises(ValueError):
list0.index(25)
def test_contains(self):
list1 = ArrayList('i', 1, 2, 3, 1, 8, 9)
self.assertTrue(2 in list1)
self.assertFalse(0 in list1)
list2 = ArrayList('u', '1', '2', '3')
self.assertTrue('2' in list2)
self.assertFalse('0' in list2)
def generateLists(self, size, inputNone=False):
arrayList = ArrayList(size)
list = []
for _ in range(size):
item = None
if not inputNone:
item = random.randint(-1000, 1000)
arrayList.append(item)
list.append(item)
return arrayList, list
def test_init_and_len(self):
# Увы, обычного теста на невылеты нет, так что пусть будет так
list0 = ArrayList('i')
list1 = ArrayList('i', 1, 2, 3, 1, 8, 9)
list2 = ArrayList('u', '1', '2', '3')
list3 = ArrayList('d', 1.1, 2.2, 3.3, 4.4, 5.5)
self.assertEqual(len(list0), 0)
self.assertEqual(len(list1), 6)
self.assertEqual(len(list2), 3)
self.assertEqual(len(list3), 5)
def testSort(self):
for i in range(51):
arrayList, pyList = self.generateLists(i)
for _ in range(i):
self.assertEqual(arrayList.sort(),
pyList.sort(),
msg="sort ascending correct")
self.assertEqual(arrayList.sort(reverse=True),
pyList.sort(reverse=True),
msg="sort descending correct")
arrayList = ArrayList()
self.assertIsNone(arrayList.sort(), msg="nothing to sort")
def test_mul_imul(self):
list0 = ArrayList('i', 0, 0, 0)
mult = 2
self.assertEqual(ArrayList('i', 0, 0, 0, 0, 0, 0), list0 * mult)
self.assertEqual(ArrayList('i', 0, 0, 0), list0)
self.assertEqual(mult, 2)
mult = 3
list0 *= mult
self.assertEqual(ArrayList('i', 0, 0, 0, 0, 0, 0, 0, 0, 0), list0)
self.assertEqual(mult, 3)
def testEqual(self):
for i in range(51):
arrayList1, pyList = self.generateLists(i)
self.assertEqual(arrayList1, pyList, msg="list not equal")
pyList.append(5)
self.assertNotEqual(arrayList1, pyList, msg="is equal")
arrayList2 = ArrayList()
arrayList2.append(5)
arrayList2.append(6)
self.assertNotEqual(arrayList2, (5, 6), msg="is equal")
list2 = [5, 6, 7]
self.assertNotEqual(arrayList2, list2, msg="is equal")
self.assertNotEqual(arrayList2, [5, 7], msg="is equal")
def test_iterable(self):
list0 = ArrayList('i', 0, 1, 2)
for i, e in enumerate(list0):
self.assertEqual(i, e)
list1 = ArrayList('i', 0)
iterator = iter(list1)
self.assertEqual(next(iterator), 0)
list1.append(2)
self.assertEqual(next(iterator), 2)
with self.assertRaises(StopIteration):
next(iterator)
def test_append(self):
list0 = ArrayList('i', 0, 0, 0)
list0.append(1)
self.assertEqual(ArrayList('i', 0, 0, 0, 1), list0)
list0.append(2)
self.assertEqual(ArrayList('i', 0, 0, 0, 1, 2), list0)
class ArrayStack:
def __init__(self):
self.data = ArrayList()
def __len__(self):
return len(self.data)
def is_empty(self):
return (len(self) == 0)
def push(self, item):
self.data.append(item)
def top(self):
if(self.is_empty() == True):
raise Exception("Stack is Empty")
return self.data[-1]
def pop(self):
if (self.is_empty() == True):
raise Exception("Stack is Empty")
return self.data.pop()
def test_pop(self):
list0 = ArrayList('i', 0, 1, 2)
self.assertEqual(list0.pop(), 2)
self.assertEqual(list0, ArrayList('i', 0, 1))
self.assertEqual(list0.pop(0), 0)
self.assertEqual(list0, ArrayList('i', 1))
def test_add_iadd(self):
list1 = ArrayList('i', 1, 2, 3, 1, 8, 9)
list01 = ArrayList('i', 0, 0, 0)
self.assertEqual(ArrayList('i', 1, 2, 3, 1, 8, 9, 0, 0, 0),
list1 + list01)
self.assertEqual(ArrayList('i', 1, 2, 3, 1, 8, 9), list1)
self.assertEqual(ArrayList('i', 0, 0, 0), list01)
list01 += list1
self.assertEqual(ArrayList('i', 0, 0, 0, 1, 2, 3, 1, 8, 9), list01)
self.assertEqual(ArrayList('i', 1, 2, 3, 1, 8, 9), list1)
class TestArrayList(unittest.TestCase):
def setUp(self):
self.ARRAY_LIST_INIT_SIZE = 2
self.array_list = ArrayList(self.ARRAY_LIST_INIT_SIZE)
def array_list_sanity_check(self, orig_len, orig_list, number_of_elements):
self.assertEqual(self.array_list.orig_len, orig_len)
self.assertEqual(self.array_list.orig_list, orig_list)
self.assertEqual(len(self.array_list), number_of_elements)
def test_initialization(self):
self.array_list_sanity_check(2, [None] * self.ARRAY_LIST_INIT_SIZE, 0)
def test_append(self):
self.array_list.append(1)
self.array_list_sanity_check(2, [1, None], 1)
self.array_list.append(2)
self.array_list_sanity_check(2, [1, 2], 2)
self.array_list.append(3)
self.array_list_sanity_check(4, [1, 2, 3, None], 3)
self.array_list.append(4)
self.array_list_sanity_check(4, [1, 2, 3, 4], 4)
def test_ordering(self):
list0 = ArrayList('i')
list10 = ArrayList('i', 1, 2, 3, 1, 8, 9)
list11 = ArrayList('i', 1, 2, 3, 1, 8, 9)
list20 = ArrayList('i', 1, 2, 3)
list21 = ArrayList('i', 1, 2, 4)
list3 = ArrayList('i', 1, 2, 3, 4, 5, 6, 7, 8, 9)
self.assertTrue(list10 == list11)
self.assertTrue(list10 >= list11)
self.assertTrue(list10 <= list11)
self.assertTrue(list10 > list0)
self.assertFalse(list10 <= list0)
self.assertTrue(list10 < list3)
self.assertTrue(list20 < list21)
self.assertTrue(list10 != list0)
self.assertTrue(list20 != list0)
self.assertTrue(list21 != list10)
self.assertTrue(list3 != list10)
self.assertFalse(list10 != list11)
def setUp(self):
self.ARRAY_LIST_INIT_SIZE = 2
self.array_list = ArrayList(self.ARRAY_LIST_INIT_SIZE)
def test_to_string(self):
list1 = ArrayList('i', 1, 2, 3, 1, 8, 9)
self.assertEqual(str(list1), "array('i', [1, 2, 3, 1, 8, 9])")
list2 = ArrayList('u', '1', '2', '3')
self.assertEqual(str(list2), "array('u', '123')")
class Simulation:
class Node():
def __init__(self, i):
self.state = None
self.recover = None
self.index = i
self.adj = None
def __init__(self, interactions, n1, alpha, recovery_days, transmission_rate, fatality_rate, initial_setting):
'''
Initialize parameters and objects for COVID-19 simulation
'''
# Constants
self.n = n1
self.ALPHA = alpha
self.RECOVERY_DAYS = recovery_days
self.TRANSMISSION_RATE = transmission_rate
self.FATALITY_RATE = fatality_rate
self.INITIAL_SETTING = initial_setting
self.INTERACTION = interactions
# States
self.CLEAN = 0
self.INFECTED = 1
self.DEAD = 2
self.RECOVERED = 3
# Initialize list
self.Nodes = ArrayList()
for i in range(self.n):
self.Nodes.append(self.Node(i))
# Set random indexes to infected
for v in self.Nodes:
if random.uniform(0,1) <= self.INITIAL_SETTING: # Probability of being infected
v.state = self.INFECTED
v.recover = self.RECOVERY_DAYS
else: # Probability of not being infected
v.state = self.CLEAN
# Initialize graph
self.Graph = self.getInteractionGraph()
def getInteractionGraph(self):
'''
Creates an AdjacencyList of size self.n to monitor node interactions
'''
start_time = time.time()
g = AdjacencyList(self.n) # Declare adjacency list
for repeat in range(self.INTERACTION): # Repeat interaction times
for j in range(0,self.n): # Repeat for all nodes
i = self.Nodes.get(random.randint(0,j)) # Get a random node
if random.uniform(0,1) < self.ALPHA: # Alpha chance
g.add_edge(j, i)
else:
ngh = g.out_edges(i.index) # Find neighbors of i
if ngh.size() > 0: # Validate that there are neighbors
k = random.choice(ngh)
g.add_edge(j, k)
for v in self.Nodes:
v.adj = g.out_edges(v.index)
elapsed_time = time.time() - start_time
print(f"Created interaction graph of size {self.n*self.INTERACTION} in", elapsed_time, "seconds")
return g
def run(self, days : int):
'''
Runs the simulation for "days" amount of times
'''
start_time = time.time()
# Initialize plot lists
day = []
clean = []
infected = []
dead = []
recovered = []
# Header
print("=== === === === === === === === === === === === === === ===")
# Day repeat
for repeat in range(1,days+1):
# Initialize node count
infected_nodes = 0
dead_nodes = 0
clean_nodes = 0
recovered_nodes = 0
# Print statistics
for i in self.Nodes:
if i.state==self.CLEAN: clean_nodes += 1
if i.state==self.INFECTED: infected_nodes += 1
elif i.state==self.DEAD: dead_nodes += 1
elif i.state==self.RECOVERED: recovered_nodes += 1
print("DAY:", repeat, "CLEAN:", clean_nodes, "INFECTED:", infected_nodes, "DEAD:", dead_nodes, "RECOVERED:", recovered_nodes)
# Plot lists
day.append(repeat)
clean.append(clean_nodes)
infected.append(infected_nodes)
dead.append(dead_nodes)
recovered.append(recovered_nodes)
# Run simulation
for v in self.Nodes: # Run through all nodes
if v.state==self.INFECTED: # Check for infection
for w in v.adj: # Find interaction neighbors self.Graph.covid_out_edges(v.index)
if w.state == self.CLEAN: # If infected interacts with clean
if random.uniform(0,1) <= self.TRANSMISSION_RATE: # Transmission chance
self.Nodes.get(w.index).state = self.INFECTED # Clean is now infected
self.Nodes.get(w.index).recover = self.RECOVERY_DAYS # Set recovery days to RECOVERY_DAYS
v.recover -= 1 # Subtract recovery day
if v.recover == 0: # If recovery is over
if random.uniform(0,1) <= self.FATALITY_RATE: # Fatality chance
v.state = self.DEAD # Node is dead
else:
v.state = self.RECOVERED # Node recovered
# Create plot
#plt.plot(day, clean, 'b')
plt.plot(day, infected, 'r')
plt.plot(day, dead, 'k')
plt.plot(day, recovered, 'g')
plt.legend(['Infected', 'Dead', 'Recovered'], loc='upper right')
elapsed_time = time.time() - start_time
# Footer
print("=== === === === === === === === === === === === === === ===")
print(f"Simulation for {days} days completed in {elapsed_time} seconds")
# View plot
opt=""
while opt!="Y" and opt!="N":
opt=input("Would you like to view the graph? (Y/N): ")
if opt=="Y":
plt.show()
input("Press enter to continue...")
plt.clf()
plt.close()
def test_remove(self):
list0 = ArrayList('i', 3, 2, 1, 0)
list0.remove(2)
self.assertEqual(list0, ArrayList('i', 3, 1, 0))
def test_reverse(self):
list0 = ArrayList('i', 3, 2, 1, 0)
i = 0
for e in reversed(list0):
self.assertEqual(e, i)
i += 1
def __init__(self, n: int):
self.n = n
self.adj = np.zeros(n, object)
for i in range(self.n):
self.adj[i] = ArrayList()
def test_insert(self):
list0 = ArrayList('i', 0, 0, 0)
list0.insert(1, 1)
self.assertEqual(list0, ArrayList('i', 0, 1, 0, 0))
list0.insert(-1, 1)
self.assertEqual(list0, ArrayList('i', 0, 1, 0, 0, 1))
list0.insert(-2, 2)
self.assertEqual(list0, ArrayList('i', 0, 1, 0, 0, 2, 1))
def test_extend(self):
list0 = ArrayList('i', 0, 0, 0, 1)
list0.extend([1, 2, 3])
self.assertEqual(list0, ArrayList('i', 0, 0, 0, 1, 1, 2, 3))
def in_edges(self, i) -> List:
out = ArrayList()
for j in range(0, self.n):
if self.has_edge(j, i): out.append(j)
return out
def __init__(self):
'''
__init__: Initialization of the base class ArrayList
'''
ArrayList.__init__(self)
def test_del(self):
list0 = ArrayList('i', 3, 2, 1, 0)
del list0[0]
self.assertEqual(list0, ArrayList('i', 2, 1, 0))
def test_is_dz_done(self):
my_array_list = ArrayList('i')
self.assertTrue(isinstance(my_array_list, abc.Reversible))
self.assertTrue(isinstance(my_array_list, abc.Collection))
import time
while(True):
while(True):
try:
numOfItems = int(input("How many items would you like to contain in the list? "))
if(numOfItems <= 0):
print("Number of items must be greater than 0")
continue
else:
break
except ValueError:
print("Must be of type integer")
continue
listOfItems = ArrayList(numOfItems)
while(True):
try:
print("Would you like the list: \n1. Sorted\n2. Reverse Sorted\n3. Semi-Sorted\n4. Unchanged")
selection = int(input("Please enter number corresponding to selection: "))
if(selection < 1 or selection > 4):
print("Please enter a number from the selection")
continue
else:
break
except ValueError:
print("Must be of type integer")
continue
switch = {1: listOfItems.sortList,
names.remove("Eric")
print(names)
print(names[0])
# 8 bytes per item for memoryt location + 4 bytes for each int
list_primes = [2, 3, 5, 7, 11, 13, 17, 19, 2]
print(list_primes)
list_primes.remove(2)
print(list_primes)
# 4 bytes per int
array_primes = array.array('i', list_primes)
array_primes.append(23)
print(array_primes)
our_list = ArrayList()
our_list.append("Eric")
our_list.append("Robert")
our_list.append("Fatemeh")
our_list.append("Susan")
our_list.append("Aya")
our_list.append("Bryant")
our_list.remove("Aya")
our_list.remove("Bryant")
our_list.insert(1, "Matt")
for index in range(len(our_list)):
print(our_list[index])
