diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c675627
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+
+build/
+compile_commands.json
+.idea
+.DS_Store
+/cmake-build-*
\ No newline at end of file
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 0000000..a8e02dc
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,80 @@
+stages:
+ - prerequisites
+ - test
+ - benchmark
+
+project_private:
+ stage: prerequisites
+ script:
+ - echo "CI_PROJECT_VISIBILITY = $CI_PROJECT_VISIBILITY"
+ - /bin/bash -c 'if [[ $CI_PROJECT_VISIBILITY = "private" ]]; then exit 0; else echo "Set your project visibility to private! Settings -> General -> Visibility -> Project visibility"; exit 1; fi'
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ tags:
+ - "fdedi"
+
+team_file_adapted:
+ stage: prerequisites
+ script:
+ - echo "CI_PROJECT_VISIBILITY = $CI_PROJECT_VISIBILITY"
+ - /bin/bash -c 'line1=$(sed -n 1p team.txt); line2=$(sed -n 2p team.txt); line3=$(sed -n 3p team.txt); error=0; [[ $line1 =~ ^Teamname:.*$ ]] && ! [[ $line1 =~ ^.*YourNameHere.*$ ]] || { echo "Enter your Teamname! You did not change the default value." && error=1; }; [[ $line2 =~ ^Realname:.*$ ]] && ! [[ $line2 =~ ^.*YourNameHere.*$ ]] || { echo "Enter your Realname! You did not change the default value."; error=1; }; [[ $line3 =~ ^MatrNr:.*$ ]] && ! [[ $line3 =~ ^.*YourMatrikelNrHere.*$ ]] || { echo "Enter your MatrNr! You did not change the default value."; error=1; }; if [ $error -ne 0 ]; then echo "Update the team.txt file. Please make sure the prefixes ('Teamname:', 'Realname:', 'MatrNr:') are still correct."; exit 1; else exit 0; fi'
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ tags:
+ - "fdedi"
+
+test:
+ stage: test
+ script:
+ - mkdir -p build/debug
+ - cd build/debug
+ - cmake -DCMAKE_BUILD_TYPE=Debug ../..
+ - make -j8
+ - ./test_all
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ paths:
+ - build/debug
+ policy: pull-push
+ tags:
+ - "fdedi"
+
+benchmark:
+ stage: benchmark
+ script:
+ - mkdir -p build/release
+ - cd build/release
+ - cmake -DCMAKE_BUILD_TYPE=Release ../..
+ - make -j8
+ - /data/delivery/measureKNN ./bench
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ paths:
+ - build/release
+ policy: pull-push
+ tags:
+ - "fdedi"
+
+clear_cache_test:
+ stage: test
+ script:
+ - rm -rf ./build/*
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ paths:
+ - build/
+ policy: pull-push
+ when: manual
+ allow_failure: true
+
+clear_cache_benchmark:
+ stage: benchmark
+ script:
+ - rm -rf ./build/*
+ cache:
+ key: "$CI_JOB_STAGE-$CI_COMMIT_REF_NAME"
+ paths:
+ - build/
+ policy: pull-push
+ when: manual
+ allow_failure: true
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..2a0ff59
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
+
+set(CMAKE_C_COMPILER gcc)
+set(CMAKE_CXX_COMPILER g++)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+project(fde20_bonusproject_3)
+
+include(lib/gtest.cmake)
+include(lib/benchmark.cmake)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -fPIC -Wall -Wextra -fno-omit-frame-pointer -march=native -Wno-unknown-pragmas")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -Wall -Wextra -fno-omit-frame-pointer -march=native")
+
+### Tests
+add_executable(test_all test/GraphTests.cpp)
+target_link_libraries(test_all gtest gtest_main pthread)
+
+### Performance Measurements for leaderboard
+add_executable(bench benchmark/BenchmarkLeaderboard.cpp include/KNN.hpp include/Util.hpp)
+
+### You can execute this binary for testing
+add_executable(forTesting src/ForTesting.cpp include/KNN.hpp include/Util.hpp)
\ No newline at end of file
diff --git a/Graph.png b/Graph.png
new file mode 100644
index 0000000..6d14463
Binary files /dev/null and b/Graph.png differ
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..9b8e566
--- /dev/null
+++ b/README.md
@@ -0,0 +1,130 @@
+# FDE Bonus Project 3 - K Nearest Neighbors
+
+#### Reminder
+
+Use Linux as operating system to work on this task. We cannot provide support for any Windows or macOs related problems.
+
+---
+## Problem Description
+
+In this project we work on a directed graph and implement an algorithm to find the _K Nearest Neighbors (knn)_ of a start node.
+
+Each edge of the directed graph has a weight.
+The K Nearest Neighbors are the `k nodes` (`result nodes`) with the cheapest path from `start node` to `result node`.
+The cost of a path is the sum of all edges of the path.
+The cheapest path is the one with the lowest cost.
+
+---
+
+**Figure 1:** *3-Nearest Neighbors search on a directed graph with start node 8. The result nodes are highlighted in green.*
+---
+
+For our example in **Figure 1** the 3-Nearest-Neighbors of `start node 8` are the result nodes: `(node: 6, cost: 0.2)`, `(node: 7, cost: 0.5)`, `(node 3, cost: 0.6)`.
+
+For this project we are only interested in the K Nearest Neighbor nodes and the cost of their path as shown in the example result.
+You do not need to keep track of the nodes on the path itself.
+
+Please make sure your K Nearest Neighbors result:
+- contains the weight of the cheapest paths from start node to each result node
+- contains no result node twice
+
+---
+## Your Task
+
+Implement an efficient **K Nearest Neighbors** algorithm for a directed graph in the function **_getKNN()_**
+in `include/KNN.hpp`. All solutions that compute correct results and achieve a time measurement better than **2
+minutes** on the leaderboard will be accepted for the bonus. It is sufficient to implement a single-thead solution, you
+do not need any parallelization.
+
+Your implementation of `getKNN()` should return the K Nearest Neighbors as a vector of `Matrix::Entries`, where each Entry
+consists of `column = the result node` and `weight = cost of the cheapest path from start node to this result node`.
+
+### Code base & dataset
+
+You only need to implement the *K Nearest Neighbors* algorithm itself in the function **_getKNN()_**. We provide you the
+functions to read the graph file and create a matrix in ```include/Matrix.hpp```.
+The file also contains a description of the matrix structure and the dataset format. However, the only function of the
+matrix you will need is ```getNeighbors()```.
+
+#### Testing your solution
+
+We provide you a smaller, but sufficient dataset (*~50MB*) in ```test/data/dataSmall.mtx``` to test your implementation,
+a test suit ```test/data/GraphTests.cpp``` and a function for developmental and experimental use ```src/ForTesting```
+(you probably won't need it).
+
+You can run the test suit executing ```test_all```. To execute ```forTesting``` you have to provide the correct program
+arguments: [CLion Tutorial](https://www.jetbrains.com/help/objc/add-environment-variables-and-program-arguments.html#add-program-arguments)
+. The binary takes three arguments:
+```forTesting ```
+Please provide the absolute file path and make sure it does not contain whitespaces. We provide an example in the
+file ```src/ForTesting.cpp```.
+
+Also, feel free to add tests if needed!
+
+### Leaderboard benchmark
+
+For the leaderboard measurement we will run the binary compiled from `BenchmarkLeaderboard.cpp` (CMake binary `bench`)
+for four queries with different *start nodes* and *k* nearest neighbors. The used dataset (*500MB*) has *400000* nodes
+with an average number of *50* outgoing edges per node. The overall runtime from start to end is measured.
+
+We use the same machine as for the previous projects:
+```Intel(R) Core(TM) i7-4770K CPU @ 3.50GHz with 4 cores, 8 hyperthreads and 32GB of memory.```
+
+**Important:** Remove all prints on `cout` before uploading onto the server, because we use `cout` to collect the
+results of the four different queries. If you don't remove them, you will receive the
+output `"what(): Your result was wrong."` (which is identical to a real wrong result).
+
+### Build
+
+A configuration file is provided to build this project with CMake. This allows you to build the project
+in the terminal but also provides the option to use Jetbrains CLion or Microsoft Visual Studio and other
+IDEs.
+
+Building from Terminal:
+Start in the project directory.
+
+```
+mkdir -p build/debug
+cd build/debug
+cmake -DCMAKE_BUILD_TYPE=Debug ../..
+make
+```
+
+This creates the binaries `test_all`, `bench` and `forTesting`.
+
+---
+## Submit
+1. Change Teamname, Realname and MatrNr in `team.txt`.
+ The Teamname will be displayed publicly on the leaderboard.
+ You can choose an arbitrary name for this, but you are also welcome to use your real name.
+ The Realname and MatrNr will be used later to verify your submission for the grade bonus.
+2. Implement the task.
+3. Commit your changes in git and push to the gitlab repository.
+4. The build system will pick up your changes and evaluate the submission.
+ If all tests succeed, your binary is handed over to the performance measurement harness.
+ The resulting times will be entered into the leaderboard.
+5. Visit http://contest.db.in.tum.de/ to see your result.
+
+Make sure your builds are not failing!
+*Left Sidebar > CI /CD > Pipelines*
+
+
+## Hints
+
+- Take care of cycles in the graph.
+- What happens if you see a node again, can it be cheaper?
+- Make sure the *K Nearest Neighbors* do not contain nodes twice. They should only contain the k cheapest neighboring
+ nodes with their minimum costs from the start node.
+- To get below 2 minutes you need to make your algorithm efficient and only process relevant nodes. Are there ways to
+ rule out nodes? When can you stop? ;) Which data structures are efficient? You are allowed to write the data
+ structures yourself or use existing ones from the standard library.
+- Feel free to add files and additional classes if needed. However, you won't need it to solve this project.
+
+## Debugging
+
+If you fail a test you might want to use CLion's **conditional breakpoints** to investigate the cause. For example when
+you fail the fourth test of `test_all` and your third node is not `1666237`, you can check what happens with the node
+using conditional breakpoints. Therefore, you can e.g. set a breakpoint when handling a node with column `1666237` by
+setting the `Condition:` `.column==1666237`. Jetbrains explains the use of breakpoints in
+CLion [here](https://www.jetbrains.com/help/clion/using-breakpoints.html#set-breakpoints).
+
diff --git a/benchmark/BenchmarkLeaderboard.cpp b/benchmark/BenchmarkLeaderboard.cpp
new file mode 100644
index 0000000..f473d12
--- /dev/null
+++ b/benchmark/BenchmarkLeaderboard.cpp
@@ -0,0 +1,44 @@
+#include "../include/Matrix.hpp"
+#include "../include/KNN.hpp"
+#include
+#include
+
+using namespace std;
+//---------------------------------------------------------------------------
+int main(int argc, char *argv[]) {
+ if (argc != 2) {
+ cout << "usage: " << argv[0] << " " << endl;
+ return 0;
+ }
+
+ // Read the matrix file and store it as internal matrix.
+ Matrix matrix = Matrix::readFile(argv[1]);
+ // Store the parameters for the different runs
+ vector> params;
+ // Read from the standard input:
+ for (string line; getline(cin, line);) {
+ // Find position to split the string
+ auto whitespace = line.find(' ');
+ // The start node
+ unsigned start = atoll(line.substr(0, whitespace).c_str());
+ // The number of neighbors we are interested in.
+ unsigned k = atoll(line.substr(whitespace, line.length()).c_str());
+ params.push_back({start, k});
+ }
+
+ // Computes the sum of all the weights, just to have some result to show.
+ auto computeSum = [](vector res) {
+ double sum = 0.0;
+ for (auto e : res)
+ sum += e.weight;
+ return sum;
+ };
+
+ // Execute the algorithm for all nodes and parameters
+ for (auto ¶m : params)
+ cout << computeSum(getKNN(matrix, param.first, param.second)) << "\n";
+
+ // Flush output buffer
+ cout.flush();
+}
+//---------------------------------------------------------------------------
diff --git a/include/KNN.hpp b/include/KNN.hpp
new file mode 100644
index 0000000..34f8db2
--- /dev/null
+++ b/include/KNN.hpp
@@ -0,0 +1,26 @@
+#ifndef FDE20_BONUSPROJECT_3_KNN_HPP
+#define FDE20_BONUSPROJECT_3_KNN_HPP
+
+#include "Matrix.hpp"
+
+//---------------------------------------------------------------------------
+/// Find the top k neighbors for the node start. The directed graph is stored in
+/// matrix m and you can use getNeighbors(node) to get all neighbors of a node.
+/// A more detailed description is provided in Matrix.hpp.
+/// The function should return the k nearest neighbors in sorted order as vector
+/// of Matrix::Entry, where Entry->column is the neighbor node and Entry->weight
+/// is the cost to reach the node from the start node.
+std::vector getKNN(const Matrix &m, unsigned start, unsigned k) {
+
+ using Entry = Matrix::Entry;
+ std::vector result;
+ result.reserve(k);
+
+ // ToDo implement your solution here
+
+ return result;
+}
+
+//---------------------------------------------------------------------------
+
+#endif // FDE20_BONUSPROJECT_3_KNN_HPP
diff --git a/include/Matrix.hpp b/include/Matrix.hpp
new file mode 100644
index 0000000..59a1ef1
--- /dev/null
+++ b/include/Matrix.hpp
@@ -0,0 +1,209 @@
+#ifndef FDE20_BONUSPROJECT_3_MATRIX_HPP
+#define FDE20_BONUSPROJECT_3_MATRIX_HPP
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+//---------------------------------------------------------------------------
+/// A sparse distance matrix representing a directed graph.
+class Matrix {
+ /// Store the matrix as list of entries.
+ ///
+ /// The entries are present in the file as: [row, column, weight]
+ /// row: current node
+ /// column: node to which we have an edge
+ /// weight: weight of the edge
+ ///
+ /// The matrix stores the entries as two vectors (lists) to save space.
+ /// entries: Only contains the column values
+ /// entryOffsets: Contains the offsets of the rows
+ /// We store the edges of the matrix therefore as follows:
+ ///
+ /// Input file:
+ /// 1 4 7
+ /// 4 6 1
+ /// 5 6 5
+ /// 6 2 4
+ /// 6 4 5
+ /// 7 1 9
+ /// ...
+ /// Stored matrix:
+ /// entries: [column, weight]
+ /// 0: [4, 7]
+ /// 1: [6, 1]
+ /// 2: [6, 5]
+ /// 3: [2, 4]
+ /// 4: [4, 5]
+ /// 5: [1, 9]
+ /// entryOffsets:
+ /// 0: [0] -> no entry for row = 0
+ /// 1: [1] -> one entry for row = 1
+ /// 2: [1] -> no entry for row = 2
+ /// 3: [1] -> no entry for row = 3
+ /// 4: [2] -> one entry for row = 4
+ /// 5: [3] -> one entry for row = 5
+ /// 6: [5] -> two entries for row = 6
+ /// 7: [6] -> one entry for row = 7
+ ///
+ /// You will only need the function getNeighbors() from the matrix
+
+public:
+ /// An entry
+ struct Entry {
+ /// The column
+ unsigned column;
+ /// The weight
+ double weight;
+ /// Constructor
+ Entry(unsigned column, double weight) : column(column), weight(weight){};
+ /// Needed for sorting.
+ bool operator<(const Entry &obj) const {
+ return this->weight < obj.weight;
+ };
+ /// Needed for equality checks
+ bool operator==(const Entry &obj) const {
+ return column == obj.column && std::fabs(weight - obj.weight) < 1E-3;
+ }
+ /// Print entry
+ std::ostream &operator<<(std::ostream &stream) {
+ return stream << "(Column: " << column << ", Weight: " << weight << ")";
+ }
+ friend std::ostream &operator<<(std::ostream &stream, const Entry &e) {
+ return stream << "(Column: " << e.column << ", Weight: " << e.weight
+ << ")";
+ }
+ };
+
+ /// An entry range
+ struct EntryRange {
+ /// The entry range
+ const Entry *from, *to;
+
+ /// Empty range?
+ bool empty() const { return from == to; }
+
+ /// First element
+ const Entry *begin() { return from; }
+
+ /// Behind the last element
+ const Entry *end() { return to; }
+ };
+
+public:
+ /// The entries of the matrix
+ std::vector entries;
+ /// The entries offsets
+ std::vector entryOffsets;
+ /// The width of the matrix
+ unsigned width = 0;
+
+public:
+ /// Get the number of rows
+ unsigned getRowCount() const { return width; }
+
+ /// This function returns all neighbors of node node (=nodes with outgoing edges
+ /// from node to the neighbors). The function returns the neighbors as range
+ /// containing all neighbor entries for the node node (= row node).
+ /// To process the returned range, just iterate over it, for example as
+ /// follows:
+ /// for (auto &e : matrix.getNeighbors(currentNode)) {
+ /// ...handle the neighbor e...
+ /// }
+ EntryRange getNeighbors(unsigned node) const {
+ return EntryRange{entries.data() + entryOffsets[node - 1],
+ entries.data() + entryOffsets[node]};
+ }
+
+ /// Read a sparse matrix file of a directed graph
+ static Matrix readFile(std::string fileName) {
+ // Check if we can read the file
+ std::ifstream in(fileName);
+ if (!in.is_open()) {
+ std::cerr << "unable to read " << fileName << std::endl;
+ exit(1);
+ }
+
+ // Matrix to store the elements
+ Matrix result;
+
+ // Check the header line
+ std::string line;
+ while (getline(in, line)) {
+ if (line.empty() || (line.front() == '%'))
+ continue;
+
+ std::stringstream s(line);
+ unsigned width, height, entries;
+ s >> width >> height >> entries;
+ if ((width != height) || (!width) || (!entries)) {
+ std::cerr << "matrix must be symmetric and non-empty" << std::endl;
+ exit(1);
+ }
+ result.width = width;
+ result.entries.reserve(entries);
+ result.entryOffsets.reserve(width + 1);
+ break;
+ }
+
+ // Read the elements
+ unsigned currentRow = 0, currentColumn = 0;
+ while (getline(in, line)) {
+ // Ignore comment lines
+ if (line.empty() || (line.front() == '%'))
+ continue;
+
+ std::stringstream s(line);
+ unsigned row, column;
+ double weight;
+ // Check if the line has the correct format
+ if (!(s >> row >> column >> weight)) {
+ std::cerr << "malformed matrix line " << line << std::endl;
+ exit(1);
+ }
+ // Check if the row and column are in the matrix range
+ if ((row > result.width) || (column > result.width)) {
+ std::cerr << "malformed matrix format, cell offset out of bounds "
+ << line << std::endl;
+ exit(1);
+ }
+ // Row numbers in the file have to be ascending
+ if (row < currentRow) {
+ std::cerr << "malformed matrix format, row number decreased " << line
+ << std::endl;
+ exit(1);
+ }
+ // For each node the edges (columns) have to be ascending
+ if (row == currentRow) {
+ if (column <= currentColumn) {
+ std::cerr << "malformed matrix format, column number decreased "
+ << line << std::endl;
+ exit(1);
+ }
+ currentColumn = column; // Update the current column to the new one
+ } else {
+ // New row-node found, update the offset table
+ result.entryOffsets.insert(result.entryOffsets.end(), row - currentRow,
+ result.entries.size());
+ // Update the current row & column
+ currentRow = row;
+ currentColumn = column;
+ }
+ // Insert the new entry
+ result.entries.push_back({column, weight});
+ }
+
+ // Update the offset for the last element (-> end of matrix)
+ result.entryOffsets.insert(result.entryOffsets.end(),
+ result.width + 1 - currentRow,
+ result.entries.size());
+
+ return result;
+ };
+};
+//---------------------------------------------------------------------------
+
+#endif // FDE20_BONUSPROJECT_3_MATRIX_HPP
diff --git a/include/Util.hpp b/include/Util.hpp
new file mode 100644
index 0000000..0c585d8
--- /dev/null
+++ b/include/Util.hpp
@@ -0,0 +1,14 @@
+#ifndef FDE20_BONUSPROJECT_3_UTIL_HPP
+#define FDE20_BONUSPROJECT_3_UTIL_HPP
+
+#include
+//---------------------------------------------------------------------------
+inline std::string getDir(const std::string &file)
+/// Returns path to file in 'file'
+{
+ size_t found = file.find_last_of("/\\");
+ return (file.substr(0, found));
+}
+//---------------------------------------------------------------------------
+
+#endif // FDE20_BONUSPROJECT_3_UTIL_HPP
diff --git a/lib/benchmark.cmake b/lib/benchmark.cmake
new file mode 100644
index 0000000..ba14b9a
--- /dev/null
+++ b/lib/benchmark.cmake
@@ -0,0 +1,30 @@
+include(ExternalProject)
+find_package(Git REQUIRED)
+
+# Get benchmark
+ExternalProject_Add(
+ benchmark_src
+ PREFIX "vendor/benchmark"
+ GIT_REPOSITORY "https://github.com/google/benchmark.git"
+ GIT_TAG v1.2.0
+ TIMEOUT 10
+ CMAKE_ARGS
+ -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/vendor/benchmark
+ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+ -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+ UPDATE_COMMAND ""
+)
+
+# Prepare benchmark
+ExternalProject_Get_Property(benchmark_src install_dir)
+set(BENCHMARK_INCLUDE_DIR ${install_dir}/include)
+set(BENCHMARK_LIBRARY_PATH ${install_dir}/lib/libbenchmark.a)
+file(MAKE_DIRECTORY ${BENCHMARK_INCLUDE_DIR})
+add_library(benchmark STATIC IMPORTED)
+set_property(TARGET benchmark PROPERTY IMPORTED_LOCATION ${BENCHMARK_LIBRARY_PATH})
+set_property(TARGET benchmark APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${BENCHMARK_INCLUDE_DIR})
+
+# Dependencies
+add_dependencies(benchmark benchmark_src)
diff --git a/lib/gtest.cmake b/lib/gtest.cmake
new file mode 100644
index 0000000..ef6f077
--- /dev/null
+++ b/lib/gtest.cmake
@@ -0,0 +1,77 @@
+include(ExternalProject)
+find_package(Git REQUIRED)
+find_package(Threads REQUIRED)
+
+# Get googletest
+ExternalProject_Add(
+ googletest
+ PREFIX "vendor/gtm"
+ GIT_REPOSITORY "https://github.com/google/googletest.git"
+ GIT_TAG release-1.8.0
+ TIMEOUT 10
+ CONFIGURE_COMMAND ""
+ BUILD_COMMAND ""
+ INSTALL_COMMAND ""
+ UPDATE_COMMAND ""
+)
+
+# Build gtest
+ExternalProject_Add(
+ gtest_src
+ PREFIX "vendor/gtm"
+ SOURCE_DIR "vendor/gtm/src/googletest/googletest"
+ INSTALL_DIR "vendor/gtm/gtest"
+ CMAKE_ARGS
+ -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/vendor/gtm/gtest
+ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+ DOWNLOAD_COMMAND ""
+ UPDATE_COMMAND ""
+)
+
+# Build gmock
+ExternalProject_Add(
+ gmock_src
+ PREFIX "vendor/gtm"
+ SOURCE_DIR "vendor/gtm/src/googletest/googlemock"
+ INSTALL_DIR "vendor/gtm/gmock"
+ CMAKE_ARGS
+ -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/vendor/gtm/gmock
+ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+ DOWNLOAD_COMMAND ""
+ UPDATE_COMMAND ""
+)
+
+# Prepare gtest
+ExternalProject_Get_Property(gtest_src install_dir)
+set(GTEST_INCLUDE_DIR ${install_dir}/include )
+set(GTEST_LIBRARY_PATH ${install_dir}/lib/libgtest.a)
+file(MAKE_DIRECTORY ${GTEST_INCLUDE_DIR})
+
+add_library(gtest STATIC IMPORTED)
+set_property(TARGET gtest PROPERTY IMPORTED_LOCATION ${GTEST_LIBRARY_PATH})
+set_property(TARGET gtest APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR})
+
+add_library(gtest_main STATIC IMPORTED)
+set(GTEST_MAIN_LIBRARY_PATH ${install_dir}/lib/libgtest_main.a)
+set_property(TARGET gtest_main PROPERTY IMPORTED_LOCATION ${GTEST_MAIN_LIBRARY_PATH})
+set_property(TARGET gtest_main APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR})
+
+# Prepare gmock
+ExternalProject_Get_Property(gmock_src install_dir)
+set(GMOCK_INCLUDE_DIR ${install_dir}/include)
+set(GMOCK_LIBRARY_PATH ${install_dir}/lib/libgmock.a)
+file(MAKE_DIRECTORY ${GMOCK_INCLUDE_DIR})
+add_library(gmock STATIC IMPORTED)
+set_property(TARGET gmock PROPERTY IMPORTED_LOCATION ${GMOCK_LIBRARY_PATH})
+set_property(TARGET gmock APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${GMOCK_INCLUDE_DIR})
+
+# Dependencies
+add_dependencies(gtest_src googletest)
+add_dependencies(gmock_src googletest)
+add_dependencies(gtest gtest_src)
+add_dependencies(gtest_main gtest_src)
+add_dependencies(gmock gmock_src)
diff --git a/src/ForTesting.cpp b/src/ForTesting.cpp
new file mode 100644
index 0000000..3e67e5a
--- /dev/null
+++ b/src/ForTesting.cpp
@@ -0,0 +1,44 @@
+#include "../include/KNN.hpp"
+#include
+#include
+
+using namespace std;
+//---------------------------------------------------------------------------
+int main(int argc, char *argv[]) {
+ // Insert the matrix file as absolute path!
+ // The path must not contain whitespaces!
+ // Usage example:
+ // forTesting Users/fde/CLionProjects/fde20-bonusproject-3/test/data/dataSmall.mtx 25 90
+ if (argc != 4) {
+ cout << "usage: " << argv[0] << " "
+ << " "
+ << "" << endl;
+ return 0;
+ }
+
+ // Read the matrix file and store it as internal matrix.
+ Matrix matrix = Matrix::readFile(argv[1]);
+ // The start node
+ unsigned start = atoll(argv[2]);
+ // The number of neighbors we are interested in.
+ unsigned k = atoll(argv[3]);
+
+ // Find the top k elements for the relevant node.
+ auto neighbors = getKNN(matrix, start, k);
+
+ cout << "Result contains " << neighbors.size() << " elements." << endl;
+
+ for(auto e: neighbors)
+ cout << e << ", ";
+ cout << endl;
+
+ // Compute the sum to check correctness
+ double sum = 0;
+ for (auto &n : neighbors)
+ sum += n.weight;
+
+ cout << sum;
+ cout.flush();
+ return 1;
+}
+//---------------------------------------------------------------------------
diff --git a/team.txt b/team.txt
new file mode 100644
index 0000000..536772d
--- /dev/null
+++ b/team.txt
@@ -0,0 +1,4 @@
+Teamname:YourNameHere
+Realname:YourNameHere
+MatrNr: YourMatrikelNrHere
+Category:Student
diff --git a/test/GraphTests.cpp b/test/GraphTests.cpp
new file mode 100644
index 0000000..60869bd
--- /dev/null
+++ b/test/GraphTests.cpp
@@ -0,0 +1,293 @@
+#include "../include/KNN.hpp"
+#include "../include/Util.hpp"
+#include
+
+using namespace std;
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top1NearestNeighbor)
+/// Test if we find even one neighbor
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 205;
+ unsigned k = 1; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected = {{1874456, 0.60409999999999997}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top3NearestNeighbors)
+/// Test if we find the top three neighbors
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 205;
+ unsigned k = 3; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+
+ std::vector expected = {{1874456, 0.60409999999999997},
+ {1552034, 1.3064519999999999},
+ {1901000, 1.510168}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top10NotReachable)
+/// Test if we handle the case where the #reachable neighbors is smaller then k.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 205;
+ unsigned k = 10; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+
+ std::sort(result.begin(), result.end());
+
+ // We can find at most 7 neighbors, although we search for 10
+ std::vector expected{{1874456, 0.6041}, {1552034, 1.30645},
+ {1901000, 1.51017}, {1836251, 1.97767},
+ {569161, 2.29636}, {572469, 2.78174},
+ {1253738, 3.14601}};
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top10NearestNeighbors)
+/// Test if we find the correct top 10 neighbors.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 210;
+ unsigned k = 10; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected{{764770, 0.664075}, {141882, 0.768491},
+ {1666237, 1.27067}, {1753834, 1.5857},
+ {107535, 1.60894}, {460877, 1.76713},
+ {172760, 2.0208}, {1171827, 2.2021},
+ {1139888, 2.34425}, {390238, 2.488}};
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top20NearestNeighbors)
+/// Test if we find the correct top 20 neighbors.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 210;
+ unsigned k = 20; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected{
+ {764770, 0.664075}, {141882, 0.768491}, {1666237, 1.27067},
+ {1753834, 1.5857}, {107535, 1.60894}, {460877, 1.76713},
+ {172760, 2.0208}, {1171827, 2.2021}, {1139888, 2.34425},
+ {390238, 2.488}, {1009041, 3.12687}, {864881, 3.19292},
+ {589617, 3.39672}, {82882, 3.76808}, {712693, 3.9045},
+ {88886, 4.06643}, {942076, 4.15386}, {860126, 4.16168},
+ {1965705, 4.77789}, {315270, 4.79742}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top30NearestNeighbors)
+/// Test if we find the correct top 30 neighbors.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 210;
+ unsigned k = 30; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected{
+ {764770, 0.664075}, {141882, 0.768491}, {1666237, 1.27067},
+ {1753834, 1.5857}, {107535, 1.60894}, {460877, 1.76713},
+ {172760, 2.0208}, {1171827, 2.2021}, {1139888, 2.34425},
+ {390238, 2.488}, {1009041, 3.12687}, {864881, 3.19292},
+ {589617, 3.39672}, {82882, 3.76808}, {712693, 3.9045},
+ {88886, 4.06643}, {942076, 4.15386}, {860126, 4.16168},
+ {1965705, 4.77789}, {315270, 4.79742}, {1390872, 5.27184},
+ {558899, 5.40213}, {1752015, 5.62945}, {246118, 5.64652},
+ {1427109, 5.94046}, {88693, 5.99056}, {1228680, 6.03966},
+ {492662, 6.06492}, {1701681, 6.55891}, {1037304, 6.91}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top50NearestNeighbors)
+/// Test if we find the correct top 50 neighbors.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 210;
+ unsigned k = 50; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected{
+ {764770, 0.664075}, {141882, 0.768491}, {1666237, 1.27067},
+ {1753834, 1.5857}, {107535, 1.60894}, {460877, 1.76713},
+ {172760, 2.0208}, {1171827, 2.2021}, {1139888, 2.34425},
+ {390238, 2.488}, {1009041, 3.12687}, {864881, 3.19292},
+ {589617, 3.39672}, {82882, 3.76808}, {712693, 3.9045},
+ {88886, 4.06643}, {942076, 4.15386}, {860126, 4.16168},
+ {1965705, 4.77789}, {315270, 4.79742}, {1390872, 5.27184},
+ {558899, 5.40213}, {1752015, 5.62945}, {246118, 5.64652},
+ {1427109, 5.94046}, {88693, 5.99056}, {1228680, 6.03966},
+ {492662, 6.06492}, {1701681, 6.55891}, {1037304, 6.91},
+ {709873, 6.92481}, {732409, 7.08362}, {582309, 7.09062},
+ {1102864, 7.15872}, {1012016, 7.21921}, {1252718, 7.23182},
+ {145385, 7.2423}, {7581, 7.24408}, {321954, 7.24432},
+ {289315, 7.52459}, {1704936, 7.57057}, {1435921, 7.66179},
+ {1993573, 7.69467}, {996893, 7.89425}, {462638, 7.94804},
+ {1181037, 7.98779}, {1385587, 7.99686}, {1689521, 8.0248},
+ {1874903, 8.04532}, {290355, 8.25242}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " << expected[i];
+ }
+}
+//---------------------------------------------------------------------------
+TEST(KNearestNeighbors, Top100NearestNeighbors)
+/// Test if we find the correct top 100 neighbors.
+{
+ // Read the matrix file and store it as internal matrix.
+ auto matrix_file = getDir(__FILE__) + "/data/dataSmall.mtx";
+ Matrix matrix = Matrix::readFile(matrix_file);
+
+ unsigned start_node = 210;
+ unsigned k = 100; // The number of neighbors we are interested in.
+
+ auto result = getKNN(matrix, start_node, k);
+
+ std::sort(result.begin(), result.end());
+ std::vector expected{
+ {764770, 0.664075}, {141882, 0.768491}, {1666237, 1.27067},
+ {1753834, 1.5857}, {107535, 1.60894}, {460877, 1.76713},
+ {172760, 2.0208}, {1171827, 2.2021}, {1139888, 2.34425},
+ {390238, 2.488}, {1009041, 3.12687}, {864881, 3.19292},
+ {589617, 3.39672}, {82882, 3.76808}, {712693, 3.9045},
+ {88886, 4.06643}, {942076, 4.15386}, {860126, 4.16168},
+ {1965705, 4.77789}, {315270, 4.79742}, {1390872, 5.27184},
+ {558899, 5.40213}, {1752015, 5.62945}, {246118, 5.64652},
+ {1427109, 5.94046}, {88693, 5.99056}, {1228680, 6.03966},
+ {492662, 6.06492}, {1701681, 6.55891}, {1037304, 6.91},
+ {709873, 6.92481}, {732409, 7.08362}, {582309, 7.09062},
+ {1102864, 7.15872}, {1012016, 7.21921}, {1252718, 7.23182},
+ {145385, 7.2423}, {7581, 7.24408}, {321954, 7.24432},
+ {289315, 7.52459}, {1704936, 7.57057}, {1435921, 7.66179},
+ {1993573, 7.69467}, {996893, 7.89425}, {462638, 7.94804},
+ {1181037, 7.98779}, {1385587, 7.99686}, {1689521, 8.0248},
+ {1874903, 8.04532}, {290355, 8.25242}, {1087049, 8.26946},
+ {33778, 8.31356}, {837520, 8.37517}, {519549, 8.38359},
+ {1209821, 8.40718}, {1052190, 8.4257}, {279645, 8.50045},
+ {347928, 8.54932}, {974685, 8.59171}, {1194601, 8.62871},
+ {362310, 8.72822}, {1836854, 8.76168}, {1819335, 8.84111},
+ {519025, 9.09717}, {948036, 9.14629}, {94509, 9.15392},
+ {45112, 9.26206}, {1331872, 9.26721}, {1071392, 9.36021},
+ {653396, 9.40626}, {124503, 9.46021}, {530001, 9.49918},
+ {18262, 9.59804}, {133240, 9.59872}, {97593, 9.73162},
+ {1368833, 9.85703}, {1920494, 9.89841}, {1136914, 9.91},
+ {80263, 9.92795}, {1858061, 9.94787}, {1307293, 9.99909},
+ {1598671, 10.1668}, {207041, 10.3269}, {70921, 10.372},
+ {1851695, 10.4148}, {1571752, 10.5047}, {1542589, 10.5344},
+ {834520, 10.5587}, {1511889, 10.6783}, {340125, 10.8356},
+ {472459, 10.8938}, {931550, 10.9064}, {64623, 10.9258},
+ {539122, 11.0281}, {304560, 11.3641}, {1241099, 11.4687},
+ {1850405, 11.5275}, {1351118, 11.5455}, {1566344, 11.5897},
+ {720881, 11.7335}};
+
+ ASSERT_EQ(result.size(), expected.size())
+ << "Result does not contain correct number of elements.";
+
+ for (size_t i = 0; i < result.size(); ++i) {
+ ASSERT_EQ(result[i], expected[i])
+ << "Result and expected result differ at index " << i << endl
+ << "result[i]: " << result[i] << endl
+ << "expected[i]: " <<