def list_test():
s = [11, 33, 22, 55, 44]
for v in s:
print(v)
a = 1
b = 3
print(s[a:b])
print(s.sort())
print(str(s))
print('bubble_sort: ', bubble_sort.sort(s))
print('quick_sort: ', quick_sort.sort(s))
xx = [x * x for x in range(10)]
print(xx)
def srt_operations(f_code, v):
if f_code == 1:
res = bogo_sort.sort(v)
return res
elif f_code == 2:
res = bubble_sort.sort(v)
return res
elif f_code == 3:
res = cocktail_sort.sort(v)
return res
elif f_code == 4:
res = comb_sort.sort(v)
return res
elif f_code == 5:
res = gnome_sort.sort(v)
return res
elif f_code == 6:
res = heap_sort.sort(v)
return res
elif f_code == 7:
res = insertion_sort.sort(v)
return res
elif f_code == 8:
res = merge_sort.sort(v)
return res
elif f_code == 9:
res = quick_sort.sort(v)
return res
elif f_code == 10:
res = quick_sort_in_place.sort(v, 0, len(v) - 1)
return res
elif f_code == 11:
res = selection_sort.sort(v)
return res
elif f_code == 12:
res = shell_sort.sort(v)
return res
def noise_removal(DDSM):
for i in (DDSM):
ds = pydicom.dcmread(i)
# initialize the y part of the pixel in the array
y = 0
# initialize x
x = 0
# size of image
pixels = ds.pixel_array.shape[0] * ds.pixel_array.shape[1]
for pixel in range(pixels):
# define the pixel we're looking at
"""
n = ds.pixel_array[y , x]
n_up = ds.pixel_array[y - 1, x]
n_upl = ds.pixel_array[y - 1, x - 1]
n_l = ds.pixel_array[y, x - 1]
n_downl = ds.pixel_array[y + 1, x - 1]
n_down = ds.pixel_array[y + 1, x]
n_downr = ds.pixel_array[y + 1, x + 1]
n_r = ds.pixel_array[y, x + 1]
n_upr = ds.pixel_array[y - 1, x + 1]
window = [n, n_up, n_upr, n_upl, n_l, n_downl, n_down, n_downr, n_r]
"""
window = pectoral_muscle.neighbors(y, x, ds.pixel_array)
# sorting
window = quick_sort.sort(window)
# set value to pixel\
ds.pixel_array[y, x] = ds.pixel_array[window[len(window) / 2][0], window[len(window) / 2][1]]
if x == ds.pixel_array.shape[1] - 1:
y = y + 1
x = 0
continue
x += 1
# print("done with iteration " + str(pixel) +" for median noise")
ds.PixelData = ds.pixel_array.tostring()
ds.save_as(i)
def test_quicksort(self):
self.output = quick_sort.sort(self.input)
self.assertEqual(self.correct, self.output)
def test_quicksort(self):
self.output = quick_sort.sort(self.input)
self.assertEqual(self.correct, self.output)
test_list2 = []
quick_times = []
test_size = [1, 10, 100, 1000]
test_size2 = [1000, 2000, 3000, 4000]
for size in test_size:
for x in range(0, size):
new_val = random.randint(math.pow(10, 4), math.pow(10, 5))
test_list.append(new_val)
#QUICK SORT
start = time.clock()
quick_sort.sort(test_list)
end = time.clock()
result_quick = end - start
quick_times.append(result_quick)
plot = []
for i in range(0, len(quick_times)):
plot.append(i)
plt.title('Analisis Experimental')
plt.plot(test_size2, quick_times)
plt.ylabel('Tiempo (s)')
plt.xlabel('Tamano (10^n)')
plt.legend(['quick sort'], loc='upper left')
plt.show()
def test_quick_sort_iterative(self, array):
assert not is_sorted(array)
quick_sort.sort(array)
assert is_sorted(array)
def test_quick_sort_recursive(self, array):
assert not is_sorted(array)
quick_sort.sort(array, iterative=False)
assert is_sorted(array)
countingSort(arr,exp)
exp *= 10
r = list()
q = list()
for i in range(1,6):
test=list(range(pow(10,i)))
for x in range(0,pow(10,i)):
test[x]=randint(pow(10,i-1), pow(10,i))
print(test)
start = time.clock()
quick_sort.sort(test)
end = time.clock()
print ("quick: ")
print (end - start)
q.append(end-start)
start = time.clock()
radixSort(test)
end = time.clock()
print ("radix: ")
print (end - start)
r.append(end-start)
print("r: "),
print(r)
print("q: "),
def quick_time(test_list): start = time.clock() quick_sort.sort(test_list) end = time.clock() result = end - start return result
