Adding delete_set func, exception handling

.gitignore

@@ -4,3 +4,4 @@ tmp
 build
 dist
 *egg-info
+__pycache__

Makefile

@@ -1,7 +1,8 @@
 CFLAGS = -Iincludes -I/Users/ehasanaj/miniconda3/envs/ml38/include/python3.8 -std=c++17 -DDEBUG -D_FORTIFY_SOURCE=2 \
 	-D_GLIBCXX_ASSERTIONS -O2 -Wall
 CC = g++
-SRC = $(wildcard src/multiset_multipacking/*.cpp)
+SRC = $(wildcard src/multiset_multicover/*.cpp)
+SRC := $(filter-out src/multiset_multicover/python_interface.cpp, $(SRC))
 OBJ = $(SRC:.cpp = .o)
 
 all: TestSet clean

includes/BaseSet.h

@@ -1,7 +1,7 @@
 #ifndef BASESET_H
 #define BASESET_H
 
-#include <algorithm> // min_element, max_element
+#include <algorithm> // min_element, max_element, copy
 #include <cstddef> // size_t
 #include <iostream> // ostream
 #include <vector>
@@ -13,6 +13,8 @@ using std::vector;
 class BaseSet {
 public:
     BaseSet(const vector<size_t>& elements);
+    BaseSet(const BaseSet& other);
+    BaseSet& operator=(const BaseSet& other);
     const size_t& operator[](size_t index) const;
     size_t size() const;
     size_t min() const;
@@ -21,8 +23,8 @@ class BaseSet {
     friend std::ostream& operator<<(std::ostream& os, const BaseSet& bs);
 
 protected:
-    const size_t _n_elements;
-    const vector<size_t> _elements;
+    size_t _n_elements;
+    vector<size_t> _elements;
 };
 
 #endif // BASESET_H

includes/GreedyCover.h

@@ -32,6 +32,7 @@ class GreedyCoverInstance {
 
     void add_multiset(const vector<size_t>& elements);
     void add_multiset(const vector<size_t>& elements, const vector<size_t>& mult);
+    void delete_multiset(size_t index);
     vector<size_t> cover(size_t coverage);
     vector<size_t> cover(size_t coverage, size_t max_iters);
     vector<size_t> cover(const vector<size_t>& coverage);
@@ -54,14 +55,16 @@ class GreedyCoverInstance {
     vector<size_t> _coverage_idx; // coverage factors for each element individually
 
 private:
-    void __update_max_coverage(const MultiSet& mset);
+    void __increase_max_coverage(const MultiSet& mset);
+    void __decrease_max_coverage(size_t index);
     void __init_leftovers();
     void __update_leftovers(const MultiSet& mset);
     void __init_remaining_msets();
     void __reset_msets();
     bool __stop() const;
     void __check_elements(const vector<size_t>& elements) const;
     vector<size_t> __cover();
+    size_t __current_coverage() const;
 };
 
 #endif // GREEDYCOVER_H

includes/MultiSet.h

@@ -30,10 +30,10 @@ class MultiSet : public BaseSet {
 protected:
     size_t _value = 0;
     vector<size_t> _leftovers;
-    const vector<size_t> _multiplicity;
+    vector<size_t> _multiplicity;
 
 private:
-    const size_t __maxel;
+    size_t __maxel;
     void __init_leftovers();
     vector<size_t> __default_multiplicity();
 };

includes/python_interface.h

@@ -1,12 +1,16 @@
 #ifndef PYTHON_INTERFACE_H
 #define PYTHON_INTERFACE_H
 
+#define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <cstddef> // size_t
 #include <vector>
+#include <exception>
+#include <string>
 
 using std::size_t;
 using std::vector;
+using std::string;
 
 #include "GreedyCover.h"
 
@@ -24,20 +28,21 @@ PyObject* create_list_from_size_t_vector(const vector<size_t>& v);
 extern "C" {
 #endif
 
-PyObject* _new_GreedyCoverInstance(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _new_GreedyCoverInstance(PyObject* self, PyObject* args, PyObject* keywds);
 
-PyObject* _GreedyCoverInstance_size(PyObject* self, PyObject* args, PyObject* keywds);
-PyObject* _GreedyCoverInstance_n_elements(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_size(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_n_elements(PyObject* self, PyObject* args, PyObject* keywds);
 
-PyObject* _GreedyCoverInstance_get_max_coverage(PyObject* self, PyObject* args, PyObject* keywds);
-PyObject* _GreedyCoverInstance_get_leftovers(PyObject* self, PyObject* args, PyObject* keywds);
-PyObject* _GreedyCoverInstance_get_multisets_incomplete_cover(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_get_max_coverage(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_get_leftovers(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_get_multisets_incomplete_cover(PyObject* self, PyObject* args, PyObject* keywds);
 
-PyObject* _GreedyCoverInstance_add_multiset(PyObject* self, PyObject* args, PyObject* keywds);
-PyObject* _GreedyCoverInstance_cover(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_add_multiset(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_delete_multiset(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_cover(PyObject* self, PyObject* args, PyObject* keywds);
 
-PyObject* _GreedyCoverInstance_solution(PyObject* self, PyObject* args, PyObject* keywds);
-PyObject* _GreedyCoverInstance__coverage_until(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance_solution(PyObject* self, PyObject* args, PyObject* keywds);
+static PyObject* _GreedyCoverInstance__coverage_until(PyObject* self, PyObject* args, PyObject* keywds);
 
 static PyMethodDef gci_methods[] = {
     { "_new_GreedyCoverInstance", (PyCFunction)_new_GreedyCoverInstance, METH_VARARGS | METH_KEYWORDS, "" },
@@ -47,6 +52,7 @@ static PyMethodDef gci_methods[] = {
     { "_GreedyCoverInstance_get_leftovers", (PyCFunction)_GreedyCoverInstance_get_leftovers, METH_VARARGS | METH_KEYWORDS, "" },
     { "_GreedyCoverInstance_get_multisets_incomplete_cover", (PyCFunction)_GreedyCoverInstance_get_multisets_incomplete_cover, METH_VARARGS | METH_KEYWORDS, "" },
     { "_GreedyCoverInstance_add_multiset", (PyCFunction)_GreedyCoverInstance_add_multiset, METH_VARARGS | METH_KEYWORDS, "" },
+    { "_GreedyCoverInstance_delete_multiset", (PyCFunction)_GreedyCoverInstance_delete_multiset, METH_VARARGS | METH_KEYWORDS, "" },
     { "_GreedyCoverInstance_cover", (PyCFunction)_GreedyCoverInstance_cover, METH_VARARGS | METH_KEYWORDS, "" },
     { "_GreedyCoverInstance_solution", (PyCFunction)_GreedyCoverInstance_solution, METH_VARARGS | METH_KEYWORDS, "" },
     { "_GreedyCoverInstance__coverage_until", (PyCFunction)_GreedyCoverInstance__coverage_until, METH_VARARGS | METH_KEYWORDS, "" },

src/multiset_multicover/BaseSet.cpp

@@ -11,6 +11,29 @@ BaseSet::BaseSet(const vector<size_t>& elements)
         throw Exception("Cannot accept negative elements.");
 }
 
+BaseSet::BaseSet(const BaseSet& other)
+    : _n_elements(other._n_elements)
+{
+    this->_elements.resize(other._n_elements);
+    std::copy(other._elements.begin(), other._elements.end(), this->_elements.begin());
+#ifdef DEBUG
+    cout << "Copying " << &other << " to " << this << endl;
+#endif
+}
+
+BaseSet& BaseSet::operator=(const BaseSet& other)
+{
+    if (this != &other) {
+        this->_n_elements = other._n_elements;
+        this->_elements.resize(other._n_elements);
+        std::copy(other._elements.begin(), other._elements.end(), this->_elements.begin());
+    }
+    return *this;
+#ifdef DEBUG
+    cout << "Assigning " << &other << " to " << this << endl;
+#endif
+}
+
 const size_t& BaseSet::operator[](size_t index) const
 {
     if (index >= this->_n_elements)

src/multiset_multicover/GreedyCover.cpp

@@ -57,14 +57,20 @@ void GreedyCoverInstance::add_multiset(const vector<size_t>& elements)
 {
     this->__check_elements(elements);
     this->_multisets.emplace_back(elements); // Implicit conversion taking place
-    this->__update_max_coverage(this->_multisets[this->size() - 1]); // Use last multiset to update coverage
+    this->__increase_max_coverage(this->_multisets[this->size() - 1]); // Use last multiset to update coverage
 }
 
 void GreedyCoverInstance::add_multiset(const vector<size_t>& elements, const vector<size_t>& mult)
 {
     this->__check_elements(elements);
     this->_multisets.emplace_back(elements, mult); // Implicit conversion taking place
-    this->__update_max_coverage(this->_multisets[this->size() - 1]);
+    this->__increase_max_coverage(this->_multisets[this->size() - 1]);
+}
+
+void GreedyCoverInstance::delete_multiset(size_t index)
+{
+    this->__decrease_max_coverage(index);
+    this->_multisets.erase(this->_multisets.begin() + index);
 }
 
 vector<size_t> GreedyCoverInstance::__cover()
@@ -90,6 +96,7 @@ vector<size_t> GreedyCoverInstance::__cover()
         }
         this->solution.push_back(*ut);
         this->__update_leftovers(this->_multisets[*ut]);
+        this->_coverage_until.push_back(this->__current_coverage());
         this->_remaining_msets.erase(ut);
     }
 
@@ -131,12 +138,20 @@ vector<size_t> GreedyCoverInstance::cover(const vector<size_t>& coverage, size_t
     return this->__cover();
 }
 
-void GreedyCoverInstance::__update_max_coverage(const MultiSet& mset)
+void GreedyCoverInstance::__increase_max_coverage(const MultiSet& mset)
 {
     for (size_t i = 0; i < mset.size(); ++i)
         this->_max_coverage[mset[i].first] += mset[i].second;
 }
 
+void GreedyCoverInstance::__decrease_max_coverage(size_t index)
+{
+    if (index >= this->size())
+        throw Exception("Index out of bound.");
+    for (size_t i = 0; i < this->_multisets[index].size(); ++i)
+        this->_max_coverage[this->_multisets[index][i].first] -= this->_multisets[index][i].second;
+}
+
 void GreedyCoverInstance::__init_leftovers()
 {
     this->_leftovers.resize(this->_n_elements);
@@ -212,4 +227,18 @@ bool GreedyCoverInstance::__stop() const
         return true;
     }
     return false;
+}
+
+size_t GreedyCoverInstance::__current_coverage() const
+{
+    size_t cc = SIZE_MAX;
+
+    if (!this->_exclusive)
+        for (size_t i = 0; i < this->_n_elements; ++i)
+            // No issue with minus since leftovers are always <=
+            cc = std::min(std::min(this->_coverage_all, this->_max_coverage[i]) - this->_leftovers[i], cc);
+    else
+        for (size_t i = 0; i < this->_n_elements; ++i)
+            cc = std::min(std::min(this->_coverage_idx[i], this->_max_coverage[i]) - this->_leftovers[i], cc);
+    return cc;
 }