diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.params b/TestON/tests/TopoPerfNext/TopoPerfNext.params
index 288023e..7eac6ef 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.params
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.params
@@ -39,8 +39,8 @@
         <onosLogFile>/opt/onos/log/karaf*</onosLogFile>
 
         #Number of times to iterate each case
-        <numIter>10</numIter>
-        <numSwitch>100</numSwitch>
+        <numIter>20</numIter>
+        <numSwitch>2</numSwitch>
         #Number of iterations to ignore initially
         <iterIgnore>2</iterIgnore>
 
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.py b/TestON/tests/TopoPerfNext/TopoPerfNext.py
index 63ba8df..147ebef 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.py
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.py
@@ -3,6 +3,10 @@
 #Topology Performance test for ONOS-next
 #
 #andrew@onlab.us
+#
+#If your machine does not come with numpy
+#run the following command:
+#sudo apt-get install python-numpy python-scipy 
 
 import time
 import sys
@@ -112,6 +116,7 @@
         import json
         import requests
         import os
+        import numpy
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS2_ip = main.params['CTRL']['ip2']
@@ -438,7 +443,9 @@
         latency_end_to_end_avg = \
                 (int(sum(latency_end_to_end_list)) / \
                  len(latency_end_to_end_list))
-   
+        latency_end_to_end_std_dev = \
+                str(round(numpy.std(latency_end_to_end_list),1))
+
         latency_ofp_to_graph_max = \
                 int(max(latency_ofp_to_graph_list))
         latency_ofp_to_graph_min = \
@@ -446,6 +453,8 @@
         latency_ofp_to_graph_avg = \
                 (int(sum(latency_ofp_to_graph_list)) / \
                  len(latency_ofp_to_graph_list))
+        latency_ofp_to_graph_std_dev = \
+                str(round(numpy.std(latency_ofp_to_graph_list),1))
 
         latency_ofp_to_device_max = \
                 int(max(latency_ofp_to_device_list))
@@ -454,6 +463,8 @@
         latency_ofp_to_device_avg = \
                 (int(sum(latency_ofp_to_device_list)) / \
                  len(latency_ofp_to_device_list))
+        latency_ofp_to_device_std_dev = \
+                str(round(numpy.std(latency_ofp_to_device_list),1))
 
         latency_t0_to_device_max = \
                 int(max(latency_t0_to_device_list))
@@ -461,7 +472,9 @@
                 int(min(latency_t0_to_device_list))
         latency_t0_to_device_avg = \
                 (int(sum(latency_t0_to_device_list)) / \
-                 len(latency_ofp_to_device_list))
+                 len(latency_t0_to_device_list))
+        latency_ofp_to_device_std_dev = \
+                str(round(numpy.std(latency_t0_to_device_list),1))
 
         latency_tcp_to_ofp_max = \
                 int(max(latency_tcp_to_ofp_list))
@@ -470,19 +483,18 @@
         latency_tcp_to_ofp_avg = \
                 (int(sum(latency_tcp_to_ofp_list)) / \
                  len(latency_tcp_to_ofp_list))
+        latency_tcp_to_ofp_std_dev = \
+                str(round(numpy.std(latency_tcp_to_ofp_list),1))
 
         main.log.report("Switch add - End-to-end latency: "+\
-                "Min: "+str(latency_end_to_end_min)+" ms "+\
-                "Max: "+str(latency_end_to_end_max)+" ms "+\
-                "Avg: "+str(latency_end_to_end_avg)+" ms ")
+                "Avg: "+str(latency_end_to_end_avg)+" ms "+
+                "Std Deviation: "+latency_end_to_end_std_dev+" ms")
         main.log.report("Switch add - OFP-to-Graph latency: "+\
-                "Min: "+str(latency_ofp_to_graph_min)+" ms "+\
-                "Max: "+str(latency_ofp_to_graph_max)+" ms "+\
-                "Avg: "+str(latency_ofp_to_graph_avg)+" ms ")
+                "Avg: "+str(latency_ofp_to_graph_avg)+" ms "+
+                "Std Deviation: "+latency_ofp_to_graph_std_dev+" ms")
         main.log.report("Switch add - TCP-to-OFP latency: "+\
-                "Min: "+str(latency_tcp_to_ofp_min)+" ms "+\
-                "Max: "+str(latency_tcp_to_ofp_max)+" ms "+\
-                "Avg: "+str(latency_tcp_to_ofp_avg)+" ms ")
+                "Avg: "+str(latency_tcp_to_ofp_avg)+" ms "+
+                "Std Deviation: "+latency_tcp_to_ofp_std_dev+" ms")
 
         if debug_mode == 'on':
             main.ONOS1.cp_logs_to_dir("/opt/onos/log/karaf.log",
@@ -506,6 +518,7 @@
         import os
         import requests
         import json
+        import numpy
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS2_ip = main.params['CTRL']['ip2']
@@ -821,44 +834,48 @@
         port_down_graph_to_ofp_avg = \
                 (sum(port_down_graph_to_ofp_list) / 
                  len(port_down_graph_to_ofp_list))
+        port_down_graph_to_ofp_std_dev = \
+                str(round(numpy.std(port_down_graph_to_ofp_list),1))
         
-        main.log.report("Port down graph-to-ofp Min: "+
-                str(port_down_graph_to_ofp_min)+" ms  Max: "+
-                str(port_down_graph_to_ofp_max)+" ms  Avg: "+
-                str(port_down_graph_to_ofp_avg)+" ms")
+        main.log.report("Port down graph-to-ofp "+
+                "Avg: "+str(port_down_graph_to_ofp_avg)+" ms "+
+                "Std Deviation: "+port_down_graph_to_ofp_std_dev+" ms")
         
         port_down_device_to_ofp_min = min(port_down_device_to_ofp_list)
         port_down_device_to_ofp_max = max(port_down_device_to_ofp_list)
         port_down_device_to_ofp_avg = \
                 (sum(port_down_device_to_ofp_list) /\
                  len(port_down_device_to_ofp_list))
+        port_down_device_to_ofp_std_dev = \
+                str(round(numpy.std(port_down_device_to_ofp_list),1))
         
-        main.log.report("Port down device-to-ofp Min: "+
-                str(port_down_device_to_ofp_min)+" ms  Max: "+
-                str(port_down_device_to_ofp_max)+" ms  Avg: "+
-                str(port_down_device_to_ofp_avg)+" ms")
+        main.log.report("Port down device-to-ofp "+
+                "Avg: "+str(port_down_device_to_ofp_avg)+" ms "+
+                "Std Deviation: "+port_down_device_to_ofp_std_dev+" ms")
         
         port_up_graph_to_ofp_min = min(port_up_graph_to_ofp_list)
         port_up_graph_to_ofp_max = max(port_up_graph_to_ofp_list)
         port_up_graph_to_ofp_avg = \
                 (sum(port_up_graph_to_ofp_list) /\
                  len(port_up_graph_to_ofp_list))
+        port_up_graph_to_ofp_std_dev = \
+                str(round(numpy.std(port_up_graph_to_ofp_list),1))
         
-        main.log.report("Port up graph-to-ofp Min: "+
-                str(port_up_graph_to_ofp_min)+" ms  Max: "+
-                str(port_up_graph_to_ofp_max)+" ms  Avg: "+
-                str(port_up_graph_to_ofp_avg)+" ms")
+        main.log.report("Port up graph-to-ofp "+
+                "Avg: "+str(port_up_graph_to_ofp_avg)+" ms "+
+                "Std Deviation: "+port_up_graph_to_ofp_std_dev+" ms")
           
         port_up_device_to_ofp_min = min(port_up_device_to_ofp_list)
         port_up_device_to_ofp_max = max(port_up_device_to_ofp_list)
         port_up_device_to_ofp_avg = \
                 (sum(port_up_device_to_ofp_list) /\
                  len(port_up_device_to_ofp_list))
+        port_up_device_to_ofp_std_dev = \
+                str(round(numpy.std(port_up_device_to_ofp_list),1))
         
-        main.log.report("Port up device-to-ofp Min: "+
-                str(port_up_device_to_ofp_min)+" ms  Max: "+
-                str(port_up_device_to_ofp_max)+" ms  Avg: "+
-                str(port_up_device_to_ofp_avg)+" ms")
+        main.log.report("Port up device-to-ofp "+
+                "Avg: "+str(port_up_device_to_ofp_avg)+" ms "+
+                "Std Deviation: "+port_up_device_to_ofp_std_dev+" ms")
 
         utilities.assert_equals(expect=main.TRUE, actual=assertion,
                 onpass="Port discovery latency calculation successful",
@@ -878,7 +895,8 @@
         import os
         import requests
         import json
-
+        import numpy 
+    
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS2_ip = main.params['CTRL']['ip2']
         ONOS3_ip = main.params['CTRL']['ip3']
@@ -1044,18 +1062,18 @@
                         graph_timestamp_3 and link_timestamp_1 and\
                         link_timestamp_2 and link_timestamp_3:
                     link_down_lat_graph1 = int(graph_timestamp_1) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                     link_down_lat_graph2 = int(graph_timestamp_2) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                     link_down_lat_graph3 = int(graph_timestamp_3) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                 
                     link_down_lat_link1 = int(link_timestamp_1) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                     link_down_lat_link2 = int(link_timestamp_2) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                     link_down_lat_link3 = int(link_timestamp_3) -\
-                            timestamp_link_down_t0
+                            int(timestamp_link_down_t0)
                 else:
                     main.log.error("There was an error calculating"+
                         " the delta for link down event")
@@ -1201,18 +1219,18 @@
                         graph_timestamp_3 and link_timestamp_1 and\
                         link_timestamp_2 and link_timestamp_3:
                     link_up_lat_graph1 = int(graph_timestamp_1) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                     link_up_lat_graph2 = int(graph_timestamp_2) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                     link_up_lat_graph3 = int(graph_timestamp_3) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                 
                     link_up_lat_link1 = int(link_timestamp_1) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                     link_up_lat_link2 = int(link_timestamp_2) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                     link_up_lat_link3 = int(link_timestamp_3) -\
-                            timestamp_link_up_t0
+                            int(timestamp_link_up_t0)
                 else:
                     main.log.error("There was an error calculating"+
                         " the delta for link down event")
@@ -1282,15 +1300,17 @@
         link_up_max = max(link_up_graph_to_system_list)
         link_up_avg = sum(link_up_graph_to_system_list) / \
                         len(link_up_graph_to_system_list)
+        link_down_std_dev = \
+                str(round(numpy.std(link_down_graph_to_system_list),1))
+        link_up_std_dev = \
+                str(round(numpy.std(link_up_graph_to_system_list),1))
 
-        main.log.report("Link down latency - Min: "+
-                str(link_down_min)+" ms  Max: "+
-                str(link_down_max)+" ms  Avg: "+
-                str(link_down_avg)+" ms")
-        main.log.report("Link up latency - Min: "+
-                str(link_up_min)+" ms  Max: "+
-                str(link_up_max)+" ms  Avg: "+
-                str(link_up_avg)+" ms")
+        main.log.report("Link down latency " +
+                "Avg: "+str(link_down_avg)+" ms "+
+                "Std Deviation: "+link_down_std_dev+" ms")
+        main.log.report("Link up latency "+
+                "Avg: "+str(link_up_avg)+" ms "+
+                "Std Deviation: "+link_up_std_dev+" ms")
 
         utilities.assert_equals(expect=main.TRUE, actual=assertion,
                 onpass="Link discovery latency calculation successful",