Cleaned up some code and naming things and started implementing max m…

…atching algorithm on bipartite graph.

.clang-tidy

@@ -1,4 +1,4 @@
-Checks: '*,-fuchsia-default-arguments,-google-readability-namespace-comments,-hicpp-deprecated-headers,-llvm-header-guard,-llvm-namespace-comment,-modernize-deprecated-headers,-fuchsia-overloaded-operator'
+Checks: '*,-google-runtime-references,-fuchsia-default-arguments,-google-readability-namespace-comments,-hicpp-deprecated-headers,-llvm-header-guard,-llvm-namespace-comment,-modernize-deprecated-headers,-fuchsia-overloaded-operator'
 WarningsAsErrors: ''
 HeaderFilterRegex: '.*'
 AnalyzeTemporaryDtors: false

CMakeLists.txt

@@ -28,7 +28,7 @@ if(${CODE})
 	set(PROJECT_LANGUAGES ${PROJECT_LANGUAGES} C CXX)
 endif()
 
-project(box_nesting
+project(BoxNesting
 	VERSION 1.0.0
 	DESCRIPTION "Algorithms and Datastructures practicum 1 box nesting algorithm"
 	LANGUAGES ${PROJECT_LANGUAGES})

include/box_nesting/Algorithm.hpp → include/BoxNesting/Algorithm.hpp

@@ -1,5 +1,7 @@
-#include <box_nesting/Box.hpp>
-#include <graph/Graph.hpp>
+#pragma once
+
+#include <BoxNesting/Box.hpp>
+#include <Graph/Graph.hpp>
 
 /**
  * @brief Contains code for the boxnesting problem
@@ -25,7 +27,7 @@ class Algorithm
 	 * @return uint64_t the number of visible boxes after running the nesting
 	 * algorithm
 	 */
-	[[nodiscard]] uint16_t runAlgorithm(const std::vector<Box>& boxes);
+	[[nodiscard]] uint16_t runAlgorithm(const std::vector<Box>& boxes) const;
 
 	/**
 	 * @brief function that appends data to an empty graph given a set of boxes.
@@ -38,7 +40,20 @@ class Algorithm
 	 *
 	 * @return Graph::Graph<Box> the graph of type BoxNesting::Box
 	 */
-	[[nodiscard]] Graph::Graph<Box> createGraphFromBoxes(const std::vector<Box>& boxes);
+	[[nodiscard]] Graph::Graph<Box> createGraphFromBoxes(const std::vector<Box>& boxes) const;
+
+private:
+	/**
+	 * @brief Run the kuhn algorithm
+	 *
+	 * @param graph The total graph
+	 * @param vertex The index of the vertex in the graph its neighbours
+	 * @param used Contains whether a vertex in the left part of the graph was used
+	 * @param pairs Contains which pairs are allready made
+	 * @return Whether pairs could be made
+	 */
+	bool kuhn(
+		const Graph::Graph<Box>& graph, uint16_t vertex, std::vector<bool>& used, std::vector<int32_t>& pairs) const;
 };
 
 } // namespace BoxNesting

include/box_nesting/Parser.hpp → include/BoxNesting/Parser.hpp

@@ -3,8 +3,8 @@
 #include <istream>
 #include <vector>
 
-#include <box_nesting/Box.hpp>
-#include <box_nesting/ParserError.hpp>
+#include <BoxNesting/Box.hpp>
+#include <BoxNesting/ParserError.hpp>
 
 /**
  * @brief Contains code for the boxnesting problem

include/graph/Graph.hpp → include/Graph/Graph.hpp

@@ -1,7 +1,6 @@
-#ifndef GRAPH_HPP
-#define GRAPH_HPP
+#pragma once
 
-#include <graph/Vertex.hpp>
+#include <Graph/Vertex.hpp>
 
 #include <unordered_map>
 #include <unordered_set>
@@ -19,9 +18,14 @@ namespace Graph
 template<class T> struct AdjacencyList
 {
 	/**
-	 * @brief Contains a vertex and the indices of its neighbors
+	 * @brief The vertex for this adjacencyList
 	 */
-	std::pair<Vertex<T>, std::vector<std::uint16_t>> content;
+	Vertex<T> vertex;
+
+	/**
+	 * @brief The vertices the head vertex can travel to via an edge.
+	 */
+	std::vector<std::uint16_t> edges;
 };
 
 /**
@@ -74,6 +78,4 @@ template<class T> class Graph
 
 } // namespace Graph
 
-#include <graph/Graph.ipp>
-
-#endif // GRAPH_HPP
+#include <Graph/Graph.ipp>

include/graph/Graph.ipp → include/Graph/Graph.ipp

@@ -1,4 +1,4 @@
-#include <graph/Graph.hpp>
+#include <Graph/Graph.hpp>
 
 #include <algorithm>
 #include <exception>
@@ -9,50 +9,48 @@ namespace Graph
 template <class T>
 void Graph<T>::addVertex(const Vertex<T>& vertex) 
 {
-	adjacencyList.emplace_back(
-		AdjacencyList<T>{std::make_pair(vertex, std::vector<std::uint16_t>())}
-	);
+	this->adjacencyList.emplace_back(AdjacencyList<T>{vertex, std::vector<std::uint16_t>()});
 }
 
 template <class T>
 void Graph<T>::addEdge(const Vertex<T>& v1, const Vertex<T>& v2)
 {
 	auto e1 = std::find_if(this->adjacencyList.begin(), this->adjacencyList.end(),
-			[&](const AdjacencyList<T>& e) { return e.content.first == v1; });
+			[&](const AdjacencyList<T>& e) { return e.vertex == v1; });
 	auto e2 = std::find_if(this->adjacencyList.begin(), this->adjacencyList.end(),
-			[&](const AdjacencyList<T>& e) { return e.content.first == v2; });
+			[&](const AdjacencyList<T>& e) { return e.vertex == v2; });
 
-	if (e1 == adjacencyList.end()) {
+	if (e1 == this->adjacencyList.end()) {
 		throw std::logic_error("addEdge, v1 vertex does not exist in adjacency list of graph.");
 	}
-	if (e2 == adjacencyList.end()) {
+	if (e2 == this->adjacencyList.end()) {
 		throw std::logic_error("addEdge, v2 vertex does not exist in adjacency list of graph.");
 	}
 
-	e1->content.second.emplace_back(e2 - this->adjacencyList.begin());
-	e2->content.second.emplace_back(e1 - this->adjacencyList.begin());
+	e1->edges.emplace_back(e2 - this->adjacencyList.begin());
+	e2->edges.emplace_back(e1 - this->adjacencyList.begin());
 }
 
 template <class T>
 bool Graph<T>::isEdgeBetween(const Vertex<T> &v1, const Vertex<T> &v2) const
 {
 	auto e1 = std::find_if(this->adjacencyList.begin(), this->adjacencyList.end(),
-			[&](const AdjacencyList<T>& e) { return e.content.first == v1; });
+			[&](const AdjacencyList<T>& e) { return e.vertex == v1; });
 	auto e2 = std::find_if(this->adjacencyList.begin(), this->adjacencyList.end(),
-			[&](const AdjacencyList<T>& e) { return e.content.first == v2; });
+			[&](const AdjacencyList<T>& e) { return e.vertex == v2; });
 
-	if (e1 == adjacencyList.end()) {
+	if (e1 == this->adjacencyList.end()) {
 		throw std::logic_error("isEdgeBetween, v1 vertex does not exist in adjacency list of graph.");
 	}
-	if (e2 == adjacencyList.end()) {
+	if (e2 == this->adjacencyList.end()) {
 		throw std::logic_error("isEdgeBetween, v2 vertex does not exist in adjacency list of graph.");
 	}
 
 	auto requiredIndex = e2 - this->adjacencyList.begin();
 
-	const auto founditerator = std::find(e1->content.second.begin(), e1->content.second.end(), requiredIndex);
+	const auto founditerator = std::find(e1->edges.begin(), e1->edges.end(), requiredIndex);
 
-	return founditerator != e1->content.second.end();
+	return founditerator != e1->edges.end();
 }
 
 template <class T>

include/graph/Vertex.hpp → include/Graph/Vertex.hpp

@@ -1,5 +1,4 @@
-#ifndef VERTEX_HPP
-#define VERTEX_HPP
+#pragma once
 
 #include <vector>
 
@@ -76,6 +75,4 @@ template<class T> struct VertexHash
 
 } // namespace Graph
 
-#include <graph/Vertex.ipp>
-
-#endif // VERTEX_HPP
+#include <Graph/Vertex.ipp>

include/graph/Vertex.ipp → include/Graph/Vertex.ipp

@@ -12,7 +12,7 @@ Vertex<T>::Vertex(T con): id(++idCounter), content(std::move(con)), visited(fals
 template <class T>
 bool Vertex<T>::operator==(const Vertex<T>& rhs) const
 {
-    return id == rhs.getId();
+    return this->id == rhs.getId();
 }
 
 template <class T>

src/Algorithm.cpp

@@ -1,22 +1,57 @@
 #include <algorithm>
+#include <vector>
 
-#include <box_nesting/Algorithm.hpp>
+#include <BoxNesting/Algorithm.hpp>
 
 /**
  * @brief Contains code for the boxnesting problem
  */
 namespace BoxNesting
 {
-uint16_t Algorithm::runAlgorithm(const std::vector<Box>& boxes)
+uint16_t Algorithm::runAlgorithm(const std::vector<Box>& boxes) const
 {
 	const auto graph = createGraphFromBoxes(boxes);
 
-	// TO-DO: implementation of Berge's lemma
+	// n is the amount of vertices in the left part and the right part
+	// of the bipartite graph. We know this is exactly the amount of vertices
+	// divided by two since we for each box we create one vertex
+	// in the left part of the graph and one in the right part of the graph
+
+	// since we know graph size doesn't exceed uint16_t we can cast here safely
+	auto n = static_cast<uint16_t>(graph.getAdjacencyList().size() / 2);
+
+	// contains indices of the vertices in right part of the graph
+	// on marked edges
+	std::vector<int32_t> pairs(n, -1);
+	// Contains whether a vertex
+	std::vector<bool> used(n, false);
+
+	// iterate through vertices of the left side
+	// of the bipartate graph
+	for (uint16_t i = 0; i < n; ++i) {
+		fill(used.begin(), used.end(), false);
+		kuhn(graph, i, used, pairs);
+	}
 
 	return 0;
 }
 
-Graph::Graph<Box> Algorithm::createGraphFromBoxes(const std::vector<Box>& boxes)
+bool Algorithm::kuhn(
+	const Graph::Graph<Box>& graph, uint16_t vertex, std::vector<bool>& used, std::vector<int32_t>& pairs) const
+{
+	if (used[vertex]) {
+		return false;
+	}
+	used[vertex] = true;
+	const auto& neighbours = graph.getAdjacencyList().at(vertex).edges;
+	for (uint16_t i = 0; i < neighbours.size(); ++i) {
+		pairs[i] = 1;
+	}
+
+	return true;
+}
+
+Graph::Graph<Box> Algorithm::createGraphFromBoxes(const std::vector<Box>& boxes) const
 {
 	Graph::Graph<Box> graph;
 
@@ -29,6 +64,11 @@ Graph::Graph<Box> Algorithm::createGraphFromBoxes(const std::vector<Box>& boxes)
 		[](const auto& b) { return Graph::Vertex<Box>(b); });
 
 	// Add two distinct vertices to the graph for each box
+	// by constructing the graph this way we know that
+	// the first half of the adjacency list belongs to
+	// to the left side of the bipartite graph
+	// and the second half of the adjacency list belongs
+	// to the right side of the bipartite graph
 	for (const auto& v : leftVertices) {
 		graph.addVertex(v);
 	}

src/Box.cpp

@@ -1,4 +1,4 @@
-#include <box_nesting/Box.hpp>
+#include <BoxNesting/Box.hpp>
 
 #include <algorithm>
 #include <sstream>

src/Parser.cpp

@@ -1,4 +1,4 @@
-#include <box_nesting/Parser.hpp>
+#include <BoxNesting/Parser.hpp>
 
 #include <climits>
 #include <regex>

src/main.cpp

@@ -1,19 +1,19 @@
-#include <box_nesting/Algorithm.hpp>
-#include <box_nesting/Parser.hpp>
-#include <box_nesting/version.hpp>
+#include <BoxNesting/Algorithm.hpp>
+#include <BoxNesting/Parser.hpp>
+#include <BoxNesting/version.hpp>
 
 #include <cstdlib>
 #include <iostream>
 
 void printVersion()
 {
 	std::cout << "program info:" << std::endl
-			  << "\tname: " << BOX_NESTING_NAME << std::endl
-			  << "\tdescription: " << BOX_NESTING_DESCRIPTION << std::endl
-			  << "\tauthor: " << BOX_NESTING_AUTHOR << std::endl
-			  << "\tversion: " << BOX_NESTING_VERSION << std::endl
-			  << "\tmail: " << BOX_NESTING_MAIL << std::endl
-			  << "\tcopyright: " << BOX_NESTING_COPYRIGHT << std::endl;
+			  << "\tname: " << BOXNESTING_NAME << std::endl
+			  << "\tdescription: " << BOXNESTING_DESCRIPTION << std::endl
+			  << "\tauthor: " << BOXNESTING_AUTHOR << std::endl
+			  << "\tversion: " << BOXNESTING_VERSION << std::endl
+			  << "\tmail: " << BOXNESTING_MAIL << std::endl
+			  << "\tcopyright: " << BOXNESTING_COPYRIGHT << std::endl;
 }
 
 void printHelp(const std::string& progName)

test/Algorithm.cpp

@@ -1,4 +1,4 @@
-#include <box_nesting/Algorithm.hpp>
+#include <BoxNesting/Algorithm.hpp>
 #include <catch2/catch.hpp>
 
 #define CATCH_CONFIG_MAIN
@@ -24,8 +24,8 @@ SCENARIO("Running the 'graph creation from a set of boxes' function")
 				for (const auto& list1 : graph.getAdjacencyList()) {
 					for (const auto& list2 : graph.getAdjacencyList()) {
 						// An edge means the box is nestable
-						auto& v1 = list1.content.first;
-						auto& v2 = list2.content.first;
+						auto& v1 = list1.vertex;
+						auto& v2 = list2.vertex;
 						if (graph.isEdgeBetween(v1, v2)) {
 							auto isNestable = v1.getContent().isNestable(v2.getContent())
 								|| v2.getContent().isNestable(v1.getContent());

test/Box.cpp

@@ -1,4 +1,4 @@
-#include <box_nesting/Box.hpp>
+#include <BoxNesting/Box.hpp>
 #include <catch2/catch.hpp>
 
 SCENARIO("Box construction and valid side lengths")

test/Graph.cpp

@@ -1,6 +1,6 @@
-#include <box_nesting/Box.hpp>
+#include <BoxNesting/Box.hpp>
+#include <Graph/Graph.hpp>
 #include <catch2/catch.hpp>
-#include <graph/Graph.hpp>
 
 SCENARIO("A graph of boxes add edged and check if no vertex has an edge to itsself", "[Graph]")
 {

test/Parser.cpp

@@ -1,4 +1,4 @@
-#include <box_nesting/Parser.hpp>
+#include <BoxNesting/Parser.hpp>
 #include <catch2/catch.hpp>
 
 #include <cstddef>