def plot_running_times():
slow_measures = []
#slow_measures.append(time.clock())
last_time = time.clock()
for size_cluster in range(2,200):
alg_project3_solution.slow_closest_pair(gen_random_clusters(size_cluster))
slow_measures.append(time.clock() - last_time)
last_time = time.clock()
fast_measures = []
#fast_measures.append(time.clock())
last_time = time.clock()
for size_cluster in range(2,200):
alg_project3_solution.fast_closest_pair(gen_random_clusters(size_cluster))
fast_measures.append(time.clock() - last_time)
last_time = time.clock()
xlabel("number of points in cluster")
ylabel("running time")
#xscale('log')
#yscale('log')
plot(range(2,200), fast_measures, '-b', label="fast_closest_pair")
plot(range(2,200), slow_measures, '-r', label="slow_closest_pair")
legend(loc="upper left")
show()
def plot_running_times():
slow_measures = []
#slow_measures.append(time.clock())
last_time = time.clock()
for size_cluster in range(2, 200):
alg_project3_solution.slow_closest_pair(
gen_random_clusters(size_cluster))
slow_measures.append(time.clock() - last_time)
last_time = time.clock()
fast_measures = []
#fast_measures.append(time.clock())
last_time = time.clock()
for size_cluster in range(2, 200):
alg_project3_solution.fast_closest_pair(
gen_random_clusters(size_cluster))
fast_measures.append(time.clock() - last_time)
last_time = time.clock()
xlabel("number of points in cluster")
ylabel("running time")
#xscale('log')
#yscale('log')
plot(range(2, 200), fast_measures, '-b', label="fast_closest_pair")
plot(range(2, 200), slow_measures, '-r', label="slow_closest_pair")
legend(loc="upper left")
show()
def question1_plot():
xvals = []
slow_cp_yvals = []
fast_cp_yvals = []
for num_clusters in range(2,200+1):
xvals.append(num_clusters)
grc = gen_random_clusters(num_clusters)
start = time.clock()
alg_project3_solution.slow_closest_pair(grc)
elapsed = (time.clock() - start)
slow_cp_yvals.append(elapsed)
start = time.clock()
alg_project3_solution.fast_closest_pair(grc)
elapsed = (time.clock() - start)
fast_cp_yvals.append(elapsed)
plt.plot(xvals, slow_cp_yvals, '-b', label='slow_closest_pair')
plt.plot(xvals, fast_cp_yvals, '-r', label='fast_closest_pair')
plt.legend(loc='upper right')
plt.xlabel('number of initial clusters ')
plt.ylabel('running time')
plt.title('desktop Python')
plt.grid(True)
plt.show()
def timed_run():
slow_times = []
fast_times = []
for i in range(2, 201):
cluster_list = gen_random_clusters(i)
start_time = time.time()
process_cluster.slow_closest_pair(cluster_list)
end_time = time.time()
ellapsed_time = end_time - start_time
slow_times.append(ellapsed_time)
start_time = time.time()
process_cluster.fast_closest_pair(cluster_list)
end_time = time.time()
ellapsed_time = end_time - start_time
fast_times.append(ellapsed_time)
return slow_times, fast_times
def plot_running_time():
slow_runnint_time = []
fast_running_time = []
x_axis = range(2, 201)
for num_clusters in x_axis:
cluster_list = gen_random_clusters(num_clusters)
cluster_list.sort(key=lambda cluster: cluster.horiz_center())
start = time.clock()
student.slow_closest_pair(cluster_list)
end_slow = time.clock()
student.fast_closest_pair(cluster_list)
end_fast = time.clock()
slow_runnint_time.append(end_slow - start)
fast_running_time.append(end_fast - end_slow)
plt.plot(x_axis, slow_runnint_time, label="slow")
plt.plot(x_axis, fast_running_time, label="fast")
plt.legend()
plt.ylabel('Running time')
plt.xlabel('Number of clusters')
plt.title("Closest Pair Algorithms Comparison")
plt.show()
def plot_running_times():
"""
Use gen_random_clusters and your favorite Python timing code to compute the running times of the
functions slow_closest_pair and fast_closest_pair for lists of clusters of size 2 to 200.
"""
x_vals = []
y_1_vals = []
y_2_vals = []
for num_clusters in range(2, 200, 1):
cluster_list = gen_random_clusters(num_clusters)
x_vals.append(num_clusters)
# measure process time (= CPU time consumed) of "slow_closest_pair"
t0 = time.clock()
p.slow_closest_pair(cluster_list)
y_1_vals.append(time.clock() - t0)
# measure process time (= CPU time consumed) of "fast_closest_pair"
t0 = time.clock()
p.fast_closest_pair(cluster_list)
y_2_vals.append(time.clock() - t0)
plt.plot(x_vals, y_1_vals, label="slow_closest_pair")
plt.plot(x_vals, y_2_vals, label="fast_closest_pair")
plt.xlabel("Input size (number of clusters)")
plt.ylabel('CPU running time (sec.)')
#tegner
plt.legend()
plt.title("Comparison of running times (desktop Python)")
#goer det hele synligt
plt.show()
def question1(filename):
xs = range(2, 201)
ys_fast, ys_slow = [], []
for n in xs:
clusters = get_random_clusters(n)
ys_fast.append(timeit(lambda: fast_closest_pair(clusters), number=1))
ys_slow.append(timeit(lambda: slow_closest_pair(clusters), number=1))
plt.plot(xs, ys_fast, '-r', label='fast_closest_pair')
plt.plot(xs, ys_slow, '-b', label='slow_closest_pair')
plt.title('Running time of two closest_pair functions (desktop Python)')
plt.xlabel('Number of initial clusters')
plt.ylabel('Running time, seconds')
plt.legend(loc='upper left')
plt.tight_layout()
plt.savefig(filename)
print('Saved plot to %s', filename)
cluster_list.append(alg_cluster.Cluster(set([]), random_x, random_y, 0, 0))
return cluster_list
# run function and record running time
start = 2
end = 200
slow_closest_list = []
fast_closest_list = []
for item in range(start,end):
# create cluster list
cluster_list = gen_random_clusters(item)
# run hierarchy
tStart = time.time()
alg_project3_solution.slow_closest_pair(cluster_list)
tStop = time.time()
slow_closest_list.append(tStop - tStart)
# run kmeans
tStart = time.time()
alg_project3_solution.fast_closest_pair(cluster_list)
tStop = time.time()
fast_closest_list.append(tStop - tStart)
# plot
def legend_example():
xvals= [i for i in range(start,end)]
yvals1 = slow_closest_list
yvals2 = fast_closest_list
def test_closest_pair_functions(self):
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 3, 100, 0.01)
self.assertEqual(p.slow_closest_pair([]), (float("inf"), -1, -1))
self.assertEqual(p.slow_closest_pair([]), p.fast_closest_pair([]))
self.assertEqual(p.slow_closest_pair([cluster1]),
(float("inf"), -1, -1))
self.assertEqual(p.slow_closest_pair([cluster1]),
p.fast_closest_pair([cluster1]))
self.assertEqual(p.slow_closest_pair([cluster1, cluster1]),
(0.0, 0, 1))
self.assertEqual(p.slow_closest_pair([cluster1, cluster1]),
p.fast_closest_pair([cluster1, cluster1]))
self.assertEqual(
p.slow_closest_pair([cluster1, cluster2, cluster3, cluster4]),
(1, 1, 3))
self.assertEqual(
p.slow_closest_pair([cluster1, cluster2, cluster3, cluster4]),
p.fast_closest_pair([cluster1, cluster2, cluster3, cluster4]))
self.assertEqual(p.slow_closest_pair([cluster1, cluster2, cluster3]),
(3, 0, 2))
self.assertEqual(p.slow_closest_pair([cluster1, cluster2, cluster3]),
p.fast_closest_pair([cluster1, cluster2, cluster3]))
self.assertEqual(
p.slow_closest_pair(
[cluster1, cluster2, cluster3, cluster4, cluster5]), (1, 1, 3))
self.assertEqual(
p.slow_closest_pair(
[cluster1, cluster2, cluster3, cluster4, cluster5]),
p.fast_closest_pair(
[cluster1, cluster2, cluster3, cluster4, cluster5]))
cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0)
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 6.1, 100, 0.01)
cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0)
cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0)
cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0)
cluster_list = [
cluster0, cluster1, cluster2, cluster3, cluster4, cluster5,
cluster6, cluster7, cluster8
]
self.assertEqual(p.slow_closest_pair(cluster_list),
p.fast_closest_pair(cluster_list))
cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0)
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 6.1, 100, 0.01)
cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0)
cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0)
cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0)
cluster_list = [
cluster0, cluster1, cluster2, cluster3, cluster4, cluster5,
cluster6, cluster7, cluster8
]
#print p.slow_closest_pair(cluster_list)
self.assertEqual(p.slow_closest_pair(cluster_list),
p.fast_closest_pair(cluster_list))
cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0)
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01)
cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0)
cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0)
cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0)
cluster_list = [
cluster0, cluster1, cluster2, cluster3, cluster4, cluster5,
cluster6, cluster7, cluster8
]
#print p.slow_closest_pair(cluster_list)
self.assertEqual(p.slow_closest_pair(cluster_list),
p.fast_closest_pair(cluster_list))
cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0)
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 30, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01)
cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0)
cluster7 = p.c.Cluster(set(["hl"]), 30, 15, 0, 0)
cluster8 = p.c.Cluster(set(["hl"]), 40, 13, 0, 0)
cluster_list = [
cluster0, cluster1, cluster2, cluster3, cluster4, cluster5,
cluster6, cluster7, cluster8
]
#print p.slow_closest_pair(cluster_list)
self.assertEqual(p.slow_closest_pair(cluster_list),
p.fast_closest_pair(cluster_list))
cluster0 = p.c.Cluster(set(["Al"]), 0, 10, 0, 0)
cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01)
cluster2 = p.c.Cluster(set(["SW"]), 4, 20, 200, 0.05)
cluster3 = p.c.Cluster(set(["Brasil"]), 4, 30, 100000000,
3) #cluster1.merge_clusters(cluster2)
cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4)
cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01)
cluster6 = p.c.Cluster(set(["hl"]), 20, 13, 0, 0)
cluster7 = p.c.Cluster(set(["hl"]), 30, 15, 0, 0)
cluster8 = p.c.Cluster(set(["hl"]), 40, 13, 0, 0)
cluster_list = [
cluster0, cluster1, cluster2, cluster3, cluster4, cluster5,
cluster6, cluster7, cluster8
]
#print p.slow_closest_pair(cluster_list)
self.assertEqual(p.slow_closest_pair(cluster_list),
p.fast_closest_pair(cluster_list))
def run_suite():
"""
Testing code for the functions written for Word Wrangler
"""
# create a TestSuite (and an object)
suite = poc_simpletest.TestSuite()
# create a set of 3 clusters
cluster1 = CC.Cluster([1, 1], 0, 0, 100, 0.00001)
cluster2 = CC.Cluster([2, 2, 2], 3, 4, 200, 0.00002)
cluster3 = CC.Cluster([3, 3, 3, 3], 6, 8, 300, 0.00003)
list_of_clusters = [cluster1, cluster2, cluster3]
# testing the slow_closest_pair function with the 3 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (5., 0, 1),
"Test #1: testing slow_closest_pair on 3 clusters")
# testing the fast_closest_pair function with the 3 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (5., 0, 1),
"Test #2: testing fast_closest_pair on 3 clusters")
# add a fourth cluster to the list
cluster4 = CC.Cluster([4, 4, 4, 4, 4], 12, 16, 400, 0.00004)
list_of_clusters.append(cluster4)
# testing the slow_closest_pair function with the 4 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (5., 0, 1),
"Test #3: testing slow_closest_pair on 4 clusters")
# testing the fast_closest_pair function with the 4 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (5., 0, 1),
"Test #4: testing fast_closest_pair on 4 clusters")
# create a set of 4 clusters
cluster1 = CC.Cluster(set([]), 0, 0, 1, 0)
cluster2 = CC.Cluster(set([]), 1, 0, 1, 0)
cluster3 = CC.Cluster(set([]), 2, 0, 1, 0)
cluster4 = CC.Cluster(set([]), 3, 0, 1, 0)
list_of_clusters = [cluster1, cluster2, cluster3, cluster4]
# testing closest_pair_strip on 4 clusters
suite.run_test(student.closest_pair_strip(list_of_clusters, 1.5, 1.0), (1.0, 1, 2),
"Test #5: testing closest_pair_strip on 4 clusters")
# create a set of 4 clusters
cluster1 = CC.Cluster(set([]), 1.0, 0.0, 1, 0)
cluster2 = CC.Cluster(set([]), 4.0, 0.0, 1, 0)
cluster3 = CC.Cluster(set([]), 5.0, 0.0, 1, 0)
cluster4 = CC.Cluster(set([]), 7.0, 0.0, 1, 0)
list_of_clusters = [cluster1, cluster2, cluster3, cluster4]
# testing fast_closest_pair on 4 clusters
suite.run_test(student.fast_closest_pair(list_of_clusters), (1.0, 1, 2),
"Test #6: testing closest_pair_strip on 4 clusters")
# create a set of 4 clusters
cluster1 = CC.Cluster(set([]), -4.0, 0.0, 1, 0)
cluster2 = CC.Cluster(set([]), 0.0, -1.0, 1, 0)
cluster3 = CC.Cluster(set([]), 0.0, 1.0, 1, 0)
cluster4 = CC.Cluster(set([]), 4.0, 0.0, 1, 0)
list_of_clusters = [cluster1, cluster2, cluster3, cluster4]
# testing closest_pair_strip on 4 clusters
suite.run_test(student.closest_pair_strip(list_of_clusters, 0.0, 4.1231059999999999), (2.0, 1, 2),
"Test #7: testing closest_pair_strip on 4 clusters")
# create a set of 4 clusters
cluster1 = CC.Cluster(set([]), -4.0, 0.0, 1, 0)
cluster2 = CC.Cluster(set([]), 0.0, -1.0, 1, 0)
cluster3 = CC.Cluster(set([]), 0.0, 1.0, 1, 0)
cluster4 = CC.Cluster(set([]), 4.0, 0.0, 1, 0)
list_of_clusters = [cluster1, cluster2, cluster3, cluster4]
# testing fast_closest_pair on 4 clusters
suite.run_test(student.fast_closest_pair(list_of_clusters), (2.0, 1, 2),
"Test #8: testing fast_closest_pair on 4 clusters")
# create a sorted list_of_clusters from a small dataset containing 8 clusters
fhandle = open("unifiedCancerData_8.txt")
list_of_clusters = []
for line in fhandle:
tokens = line.split(',')
cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]),
int(tokens[3]), float(tokens[4]))
list_of_clusters.append(cluster)
list_of_clusters.sort(key = lambda cluster: cluster.horiz_center())
print "The following list_of_clusters was loaded:"
for index in range(len(list_of_clusters)):
print index, list_of_clusters[index]
print
# testing the slow_closest_pair function with 8 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (2.4479655653349655, 5, 7),
"Test #9: testing slow_closest_pair on 8 clusters")
# testing the fast_closest_pair function with 8 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (2.4479655653349655, 5, 7),
"Test #10: testing fast_closest_pair on 8 clusters")
# testing the hierarchical_clustering function with 8 clusters
clustering_result = student.hierarchical_clustering(list_of_clusters, 5)
for index in range(len(clustering_result)):
print clustering_result[index]
print
# testing the kmeans_clustering function with 8 clusters
clustering_result = student.kmeans_clustering(list_of_clusters, 5, 3)
for index in range(len(clustering_result)):
print clustering_result[index]
print
# create a sorted list_of_clusters from a small dataset containing 17 clusters
fhandle = open("unifiedCancerData_17.txt")
list_of_clusters = []
for line in fhandle:
tokens = line.split(',')
cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]),
int(tokens[3]), float(tokens[4]))
list_of_clusters.append(cluster)
list_of_clusters.sort(key = lambda cluster: cluster.horiz_center())
# testing the slow_closest_pair function with 17 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (1.9439662413427632, 9, 10),
"Test #11: testing slow_closest_pair on 17 clusters")
# testing the fast_closest_pair function with 17 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (1.9439662413427632, 9, 10),
"Test #12: testing fast_closest_pair on 17 clusters")
# create a sorted list_of_clusters from a small dataset containing 24 clusters
fhandle = open("unifiedCancerData_24.txt")
list_of_clusters = []
for line in fhandle:
tokens = line.split(',')
cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]),
int(tokens[3]), float(tokens[4]))
list_of_clusters.append(cluster)
list_of_clusters.sort(key = lambda cluster: cluster.horiz_center())
print "The following list_of_clusters was loaded:"
for index in range(len(list_of_clusters)):
print index, list_of_clusters[index]
print
# testing the kmeans_clustering function with 24 clusters
clustering_result = student.kmeans_clustering(list_of_clusters, 10, 1)
print "This output was created by kmeans_slustering:"
for index in range(len(clustering_result)):
print index, clustering_result[index]
print
# create a sorted list_of_clusters from a small dataset containing 39 clusters
fhandle = open("unifiedCancerData_39.txt")
list_of_clusters = []
for line in fhandle:
tokens = line.split(',')
cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]),
int(tokens[3]), float(tokens[4]))
list_of_clusters.append(cluster)
list_of_clusters.sort(key = lambda cluster: cluster.horiz_center())
# testing the slow_closest_pair function with 39 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (1.6612217536988727, 22, 24),
"Test #13: testing slow_closest_pair on 39 clusters")
# testing the fast_closest_pair function with 39 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (1.6612217536988727, 22, 24),
"Test #14: testing fast_closest_pair on 39 clusters")
# create a sorted list_of_clusters from a small dataset containing 111 clusters
fhandle = open("unifiedCancerData_111.csv")
list_of_clusters = []
for line in fhandle:
tokens = line.split(',')
cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]),
int(tokens[3]), float(tokens[4]))
list_of_clusters.append(cluster)
list_of_clusters.sort(key = lambda cluster: cluster.horiz_center())
print "The following list_of_clusters was loaded:"
for index in range(len(list_of_clusters)):
print index, list_of_clusters[index]
print
# testing the slow_closest_pair function with 111 cluster list
suite.run_test(student.slow_closest_pair(list_of_clusters), (1.266216002018164, 79, 81),
"Test #15: testing slow_closest_pair on 111 clusters")
# testing the fast_closest_pair function with 111 cluster list
suite.run_test(student.fast_closest_pair(list_of_clusters), (1.266216002018164, 79, 81),
"Test #16: testing fast_closest_pair on 111 clusters")
# testing the hierarchical_clustering function with 111 clusters
clustering_result = student.hierarchical_clustering(list_of_clusters, 5)
for index in range(len(clustering_result)):
print clustering_result[index]
print
# report number of tests and failures
print
suite.report_results()
return _cluster_list
#####################################
# Code for answering question 1 of the application
# Measure the running times for the functions slow_closest_pair and fast_closest_pair
num_clusters = []
running_times_slow = []
running_times_fast = []
for index in range(2,201):
cluster_list = gen_random_clusters(index)
num_clusters.append(index)
start_time = time.time()
distance = sol.slow_closest_pair(cluster_list)
end_time = time.time()
running_times_slow.append(end_time - start_time)
start_time = time.time()
distance = sol.fast_closest_pair(cluster_list)
end_time = time.time()
running_times_fast.append(end_time - start_time)
if index % 10 == 0:
print "=====> Covered clusterlist up to", index
# Create plot of the result
plt.plot(num_clusters, running_times_slow, '-b', label='slow_closest_pair')
plt.plot(num_clusters, running_times_fast, '-r', label='fast_closest_pair')
plt.legend(loc='upper left')
plt.grid(True)
plt.title("Plot 9: running times of slow_closest_pair and fast_closest_pair")
def test01(self):
(distance,idx1,idx2) = slow_closest_pair([Cluster(set([]), 0, 0, 1, 0), Cluster(set([]), 1, 0, 1, 0), Cluster(set([]), 2, 0, 1, 0), Cluster(set([]), 3, 0, 1, 0)])
self.assertAlmostEqual(distance, 1.0)
