public void execute(){
		// initialize all variables
		numberOfSteps = maximumStepValue / currentStepValue;
		
		timesToComputeTheAverageOf = new long[numberOfPasses];
		
		timesDijkstraArrayHeap = new long[numberOfSteps];
		timesDijkstraFibHeap = new long[numberOfSteps];
		timesThorupMST = new long[numberOfSteps];
		timesThorupDS = new long[numberOfSteps];
		timesThorupVisit = new long[numberOfSteps];
		
		allStepValues = new int[numberOfSteps];
		
		System.out.println();
		
		// run this series of measurement until the maximum step value
		while (currentStepValue <= maximumStepValue) {
			// remember the current step value for evaluation purposes
			allStepValues[currentStep] = currentStepValue;
			
			// generate the next test instance
			System.out.println();
			System.out.print("Generating a random graph with " +
					numberOfVerticesCurrent + " vertices...");
			
			AdjacencyListWeightedDirectedGraph<WeightedEdge> graph =
				generateGraph();
			
			System.out.println(" done: Generated graph has " +
					graph.getNumberOfEdges() + " edges.");

			
			// run Dijkstra's algorithm with an array heap and take the time
			System.out.print("Running Dijkstra with an array priority " +
					"queue...");
			
			Dijkstra dijkstra = new Dijkstra();
			
			for (int pass = 0; pass < numberOfPasses; pass++) {
				start = System.currentTimeMillis();
				dijkstra.findShortestPaths(graph, 0,
						new ArrayPriorityQueue<Integer>
							(numberOfVerticesCurrent));
				stop = System.currentTimeMillis();
				
				timesToComputeTheAverageOf[pass] = stop - start;
			}
	
			// compute the average
			timesDijkstraArrayHeap[currentStep] =
				getAverage(timesToComputeTheAverageOf);
					
			// show the result
			System.out.println(" took " + timesDijkstraArrayHeap[currentStep] +
					" ms (average of " + numberOfPasses + " passes).");
			
			
			// run Dijkstra's algorithm with a Fibonacci heap and take the time
			System.out.print("Running Dijkstra with a Fibonacci heap...");
			
			for (int pass = 0; pass < numberOfPasses; pass++) {
				start = System.currentTimeMillis();
				dijkstra.findShortestPaths(graph, 0,
						new FibonacciHeap<Integer>());
				stop = System.currentTimeMillis();
				
				timesToComputeTheAverageOf[pass] = stop - start;
			}
	
			// compute the average
			timesDijkstraFibHeap[currentStep] =
				getAverage(timesToComputeTheAverageOf);
					
			// show the result
			System.out.println(" took " + timesDijkstraFibHeap[currentStep] +
					" ms (average of " + numberOfPasses + " passes).");
	
			
			/*
			 * construct the msb-minimum spanning tree for Thorup's algorithm
			 * and take the time
			 */
			System.out.print("Running Thorup...");
			
			Thorup thorup = new Thorup();
			
			for (int pass = 0; pass < numberOfPasses; pass++) {
				start = System.currentTimeMillis();
				thorup.constructMinimumSpanningTree(graph,
						new Kruskal(new UnionFindStructureTarjan<Integer>()));
				stop = System.currentTimeMillis();
				
				timesToComputeTheAverageOf[pass] = stop - start;
			}
	
			// compute the average
			timesThorupMST[currentStep] =
				getAverage(timesToComputeTheAverageOf);
					
			// show the result
			System.out.print(" took " + timesThorupMST[currentStep] +
					" ms for constructing the MST, ");
			
			
			/*
			 * construct all other data structures for Thorup's algorithm and
			 * take the time
			 */
			for (int pass = 0; pass < numberOfPasses; pass++) {
				start = System.currentTimeMillis();
				thorup.constructOtherDataStructures
					(new UnionFindStructureTarjan<Integer>(),
					 new SplitFindminStructureGabow<Integer>
						(numberOfVerticesCurrent));
				stop = System.currentTimeMillis();
				
				timesToComputeTheAverageOf[pass] = stop - start;
			}
	
			// compute the average
			timesThorupDS[currentStep] =
				getAverage(timesToComputeTheAverageOf);
					
			// show the result
			System.out.print(timesThorupDS[currentStep] +
					" ms for constructing the other data structures,");
			
			
			// run Thorup's algorithm and take the time
			for (int pass = 0; pass < numberOfPasses; pass++) {
				if (pass > 0) {
					thorup.cleanUpBetweenQueries
						(new SplitFindminStructureGabow<Integer>
							(graph.getNumberOfVertices()));
				}

				start = System.currentTimeMillis();
				thorup.findShortestPaths(0);
				stop = System.currentTimeMillis();
				
				timesToComputeTheAverageOf[pass] = stop - start;
			}
	
			// compute the average
			timesThorupVisit[currentStep] =
				getAverage(timesToComputeTheAverageOf);
					
			// show the result
			System.out.println(" and " + timesThorupVisit[currentStep] +
					" ms for visiting all vertices (average of " +
					numberOfPasses + " passes).");
			
			
			// prepare next iteration
			currentStepValue += allStepValues[0];
			currentStep++;
			
			customUpdate();
		}
		
		if (writeTableColumns) {
			// write all values and running times to the console
			System.out.println();
			
			System.out.println("All step values:");
			writeTableColumn(allStepValues);
			writeLatexTableRow(allStepValues);
			System.out.println();
			
			System.out.println("All times of Dijkstra with array heap:");
			writeTableColumn(timesDijkstraArrayHeap);
			writeLatexTableRow(timesDijkstraArrayHeap);
			System.out.println();
			
			System.out.println("All times of Dijkstra with Fibonacci heap:");
			writeTableColumn(timesDijkstraFibHeap);
			writeLatexTableRow(timesDijkstraFibHeap);
			System.out.println();
			
			System.out.println("All times of Thorup (construct MST):");
			writeTableColumn(timesThorupMST);
			writeLatexTableRow(timesThorupMST);
			System.out.println();
			
			System.out.println("All times of Thorup (construct other DS):");
			writeTableColumn(timesThorupDS);
			writeLatexTableRow(timesThorupDS);
			System.out.println();
			
			System.out.println("All times of Thorup (visit)");
			writeTableColumn(timesThorupVisit);
			writeLatexTableRow(timesThorupVisit);
			System.out.println();
		}
	}