basic project setup

.gitignore

@@ -30,3 +30,14 @@
 *.exe
 *.out
 *.app
+
+# visual studio build folder
+Debug/*
+Release/*
+
+# visual studio project files
+.vs/*
+median-comparison.sln
+median-comparison.vcxproj
+median-comparison.vcxproj.filters
+median-comparison.vcxproj.user

Timing.cpp

@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <iostream>
+#include <sstream>
+#include "Timing.h"
+
+Timing* Timing::mInstance = 0;
+
+/**
+ * Singleton: Get instance.
+ */
+Timing* Timing::getInstance() {
+	if (mInstance == 0) {
+		mInstance = new Timing();
+	}
+
+	return mInstance;
+}
+
+/**
+ * Start recording time with any name.
+ */
+void Timing::startRecord(const std::string& name) {
+	auto start = std::chrono::high_resolution_clock::now();
+
+	auto it = mRecordings.find(name);
+	if (it != mRecordings.end()) {
+		it->second = start;
+	} else {
+		mRecordings.insert(std::pair<std::string, std::chrono::high_resolution_clock::time_point>(name, start));
+	}
+
+}
+
+/**
+ * Stop recording time with any name.
+ */
+void Timing::stopRecord(const std::string& name) {
+	auto end = std::chrono::high_resolution_clock::now();
+
+	auto it = mRecordings.find(name);
+	if (it != mRecordings.end()) {
+		auto start = it->second;
+		auto result = end - start;
+
+		mResults.insert(std::pair<std::string, std::chrono::duration<double, std::milli> >(name, result));
+	}
+
+}
+
+/**
+ * Print measured results human-readable.
+ * Set prettyPrint to true to display mm:ss.ms instead of ms.
+ */
+void Timing::print(const bool prettyPrint) const {
+	std::cout << "-----" << std::endl << "Results: " << std::endl << "-----" << std::endl;
+
+	auto it = mResults.begin();
+	while(it != mResults.end()) {
+		if (prettyPrint) {
+			std::cout << it->first << ": " << parseDate((int) it->second.count()) << std::endl;
+		} else {
+			std::cout << it->first << ": " << it->second.count() << "ms" << std::endl;
+		}
+		it++;
+	}
+
+	std::cout << "-----" << std::endl;
+}
+
+/**
+ * Parse date from ms to mm:ss.ms.
+ */
+std::string Timing::parseDate(const int ms) const {
+	int minutes = (int) (ms / 1000 / 60);
+	int seconds = (int) ((ms % (1000 * 60)) / 1000);
+	int milliseconds = (int) (ms % 1000);
+
+	std::ostringstream stringStream;
+	if (seconds == 60) {
+		stringStream << minutes + 1 << ":00" << seconds << ".";
+	} else {
+  	stringStream << minutes << ":" << (seconds < 10 ? "0" : "") << seconds << ".";
+	}
+
+	if (milliseconds < 100) {
+		if (milliseconds < 10) {
+			stringStream << "00" << milliseconds;
+		} else {
+			stringStream << "0" << milliseconds;
+		}
+	} else {
+		stringStream << milliseconds;
+	}
+
+  return stringStream.str();
+}
+
+/**
+ * Get results of setup, computation and finalization in form:
+ * mm:ss.ms;mm:ss.ms;mm.ss.ms
+ */
+std::string Timing::getResults() const {
+	std::ostringstream stringStream;
+
+	auto start = mResults.find("setup");
+	if (start != mResults.end()) {
+		stringStream << parseDate((int) start->second.count()) << ";";
+	}
+
+	auto computation = mResults.find("computation");
+	if (computation != mResults.end()) {
+		stringStream << parseDate((int) computation->second.count()) << ";";
+	}
+
+	auto finalization = mResults.find("finalization");
+	if (start != mResults.end()) {
+		stringStream << parseDate((int) finalization->second.count());
+	}
+
+	return stringStream.str();
+}
+
+/**
+ * Start recording the setup time.
+ */
+void Timing::startSetup() {
+	this->startRecord("setup");
+}
+
+/**
+ * Stop recording the setup time.
+ */
+void Timing::stopSetup() {
+	this->stopRecord("setup");
+}
+
+/**
+ * Start recording the computation time.
+ */
+void Timing::startComputation() {
+	this->startRecord("computation");
+}
+
+/**
+ * Stop recording the computation time.
+ */
+void Timing::stopComputation() {
+	this->stopRecord("computation");
+}
+
+/**
+ * Start recording the finalization time.
+ */
+void Timing::startFinalization() {
+	this->startRecord("finalization");
+}
+
+/**
+ * Stop recording the finalization time.
+ */
+void Timing::stopFinalization() {
+	this->stopRecord("finalization");
+}

Timing.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <chrono>
+#include <string>
+#include <map>
+
+/**
+ * Measure high precision time intervals (using std::chrono).
+ * Author: Karl Hofer <hoferk@technikum-wien.at>
+ */
+class Timing {
+public:
+	static Timing* getInstance();
+
+	void startSetup();
+	void stopSetup();
+	void startComputation();
+	void stopComputation();
+	void startFinalization();
+	void stopFinalization();
+
+	void startRecord(const std::string& name);
+	void stopRecord(const std::string& name);
+	void print(const bool prettyPrint = false) const;
+	std::string getResults() const;
+
+private:
+	Timing() {};
+	std::map<std::string, std::chrono::high_resolution_clock::time_point > mRecordings;
+	std::map<std::string, std::chrono::duration<double, std::milli> > mResults;
+	std::string parseDate(const int ms) const;
+
+	static Timing* mInstance;
+};

fileHandler.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+std::vector<size_t>& readFromFile(const char* filePath)
+{
+    std::vector<size_t> numbers;
+    std::cout << "read file: " << filePath << "..." << std::endl;
+    std::ifstream in(filePath);
+    if (in.is_open())
+    {
+        std::string line;
+        std::getline(in, line);
+        std::cout << "read line " << line << std::endl;
+        size_t count = std::stoi(line);
+
+        std::cout << "total: " << count << " elems" << std::endl;
+
+        size_t idx = 0;
+        while (in.good() && idx < count) {
+            std::getline(in, line);
+            std::cout << "readline: " << line << std::endl;
+            //long val = std::stol(line);
+            //std::cout << "as long: " << val << std::endl;
+            unsigned long ulval = std::stoul(line);
+            std::cout << "as unsigned long: " << ulval << std::endl;
+            numbers.push_back(ulval);
+            idx++;
+        }
+    }
+    else std::cout << "Error opening " << filePath << std::endl;
+
+    if (!in.eof() && in.fail())
+        std::cout << "error reading " << filePath << std::endl;
+
+    in.close();
+    return numbers;
+}

main.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+
+#include "fileHandler.h"
+#include "Timing.h"
+
+int main(int argc, char** argv) {
+    Timing::getInstance()->startRecord("init");
+    std::vector<size_t> numbers = readFromFile("testdata");
+    Timing::getInstance()->stopRecord("init");
+
+    Timing::getInstance()->startRecord("test");
+    Timing::getInstance()->stopRecord("test");
+    //Timing::getInstance()->getResults();
+    Timing::getInstance()->print();
+    return 0;
+}

testdata

@@ -999998,4 +999998,4 @@
 41388837
 1315454792
 3184343159
-3292230824
+3292230824