initial commit

.gitignore

@@ -0,0 +1,5 @@
+[Oo]ut/
+[Bb]uild/
+
+.vs/
+.vscode/

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "vendor/eigen"]
+	path = vendor/eigen
+	url = https://gitlab.com/libeigen/eigen.git
+	branch = 3.4

CMakeLists.txt

@@ -0,0 +1,9 @@
+# CMakeList.txt : Top-level CMake project file, do global configuration
+# and include sub-projects here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+project ("CakeCutting")
+
+# Include sub-projects.
+add_subdirectory ("src")

CMakeSettings.json

@@ -0,0 +1,22 @@
+{
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "inheritEnvironments": [ "msvc_x64_x64" ],
+      "buildRoot": "${projectDir}\\out\\build\\${name}",
+      "installRoot": "${projectDir}\\out\\install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "variables": [
+        {
+          "name": "BUILD_TESTING",
+          "value": "False",
+          "type": "BOOL"
+        }
+      ]
+    }
+  ]
+}

README.md

@@ -0,0 +1,3 @@
+# Cake Cutting Algorithms
+
+How to cut a cake

src/Agent.cpp

@@ -0,0 +1,42 @@
+#include "Agent.hpp"
+
+#include <chrono>
+
+std::uniform_real_distribution<double> Agent::coefficientRange = std::uniform_real_distribution<double>(-1.0f, 1.0f);
+std::default_random_engine Agent::generator = std::default_random_engine(std::random_device{}());
+
+Agent::Agent(unsigned int polynomialDegree) :
+	normalizationFactor(0.0f)
+{
+	for (size_t k = 0; k < polynomialDegree; k++)
+	{
+		double coefficient = coefficientRange(generator) / (k + 1);
+
+		coefficients.push_back(coefficient);
+		normalizationFactor += coefficient;
+	}
+
+	normalizationFactor = 1.0f / normalizationFactor;
+}
+
+Agent::~Agent()
+{
+}
+
+double Agent::operator()(const Piece& piece)
+{
+	double value = 0.0f;
+	for(const Interval& interval : piece.intervals)
+		value += Eval(interval.max) - Eval(interval.min);
+
+	return value;
+}
+
+double Agent::Eval(double x)
+{
+	double value = 0.0f;
+	for (size_t k = 0; k < coefficients.size(); k++)
+		value += coefficients[k] * pow(x, k + 1);
+
+	return normalizationFactor * value;
+}

src/Agent.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <vector>
+#include <random>
+
+struct Interval
+{
+	double min, max;
+};
+
+struct Piece
+{
+	Piece() {}
+	Piece(double min, double max) :
+		intervals({ {min, max} })
+	{}
+
+	std::vector<Interval> intervals;
+};
+
+class Agent
+{
+public:
+	static std::uniform_real_distribution<double> coefficientRange;
+	static std::default_random_engine generator;
+
+public:
+	Agent(unsigned int polynomialDegree);
+	~Agent();
+
+	double operator()(const Piece& piece);
+	double Eval(double x);
+
+private:
+	std::vector<double> coefficients;
+	double normalizationFactor;
+};

src/CMakeLists.txt

@@ -0,0 +1,13 @@
+# CMakeList.txt : CMake project for CakeCutting, include source and define
+# project specific logic here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+# Add source to this project's executable.
+add_executable (CakeCutting "main.cpp" "Agent.hpp" "Agent.cpp")
+
+target_include_directories (CakeCutting PRIVATE 
+	${CMAKE_SOURCE_DIR}/vendor/eigen
+)
+
+# TODO: Add tests and install targets if needed.

src/main.cpp

@@ -0,0 +1,94 @@
+#include <iostream>
+#include <iomanip>
+#include <Eigen/Dense>
+
+#include "Agent.hpp"
+
+
+int main(int argc, char** argv)
+{
+	constexpr size_t numAgents = 5;
+	std::vector<Agent> agents;
+	std::vector<Piece> initialPartition(numAgents);
+
+	for (size_t k = 0; k < numAgents; k++)
+	{
+		agents.emplace_back(5);
+		initialPartition[k] = Piece((double)k / numAgents, (double)(k + 1) / numAgents);
+	}
+
+	std::cout << "Initialized " << numAgents << " random agents and created the following partition: " << std::endl;
+	for (const Piece piece : initialPartition)
+		std::cout << "   [" << piece.intervals[0].min << ", " << piece.intervals[0].max << "]" << std::endl;
+	std::cout << std::endl;
+
+	Eigen::MatrixXd M(numAgents, numAgents);
+	for (size_t i = 0; i < numAgents; i++)
+		for (size_t j = 0; j < numAgents; j++)
+			M(i, j) = agents[i](initialPartition[j]);
+
+	std::cout << "M = " << std::endl << M << std::endl;
+
+	M = M.inverse();
+	std::cout << "M^-1 = " << std::endl << M << std::endl;
+
+	double t = M.minCoeff();
+
+	double delta = (double)(numAgents - 1) / (numAgents * (1.0 - t * numAgents));
+	std::cout << "delta = " << delta << std::endl;
+
+	Eigen::MatrixXd N(numAgents, numAgents);
+	for (size_t i = 0; i < numAgents; i++)
+		for (size_t j = 0; j < numAgents; j++)
+			N(i, j) = (i == j) ?
+				1.0 / (numAgents + delta) :
+				1.0 / numAgents - delta / (numAgents - 1);
+
+	std::cout << "N = " << std::endl << N << std::endl;
+
+	Eigen::MatrixXd R = M * N;
+	std::cout << "R = " << std::endl << R << std::endl;
+
+	std::vector<Piece> intermediatePartition(numAgents);
+
+	double epsilon = delta / (double)(numAgents * numAgents);
+	for (size_t j = 0; j < numAgents; j++)
+	{
+		double divisor = R.row(j).sum();
+		double min = initialPartition[j].intervals[0].min;
+		double len = initialPartition[j].intervals[0].max - initialPartition[j].intervals[0].min;
+
+		for (size_t n = 0; n < numAgents; n++)
+		{
+			double ratio = R(j, n) / divisor;
+			intermediatePartition[j].intervals.push_back({ min, min + len * ratio });
+			min += len * ratio;
+		}
+
+	}
+
+	std::vector<Piece> finalPartition(numAgents);
+	for (size_t i = 0; i < numAgents; i++)
+		for (size_t n = 0; n < numAgents; n++)
+			finalPartition[i].intervals.push_back(intermediatePartition[n].intervals[i]);
+
+	std::cout << "FINAL PARTITION" << std::endl;
+	std::cout << "====================================================" << std::endl;
+	for (size_t n = 0; n < numAgents; n++)
+	{
+		std::cout << "Agent " << n << ": {" << std::endl;
+		for (size_t k = 0; k < numAgents; k++)
+			std::cout << "    [" << std::setprecision(6) << std::fixed << finalPartition[n].intervals[k].min << ", " << std::setprecision(6) << std::fixed << finalPartition[n].intervals[k].max << "]" << std::endl;
+
+		std::cout << "}, mu = " << agents[n](finalPartition[n]);
+
+		std::cout << " (";
+		for (size_t k = 0; k < numAgents; k++)
+			if (k != n)
+				std::cout << agents[n](finalPartition[k]) << ", ";
+		
+		std::cout << ")" << std::endl;
+	}
+
+	return 0;
+}

vendor/eigen

@@ -0,0 +1 @@
+Subproject commit 34e5f34b391e9b964917d54139aae1ecf522d4e5