added cpp implementation for prims

Author: Prerak Singh

pydatastructs/graphs/_backend/cpp/Algorithms.hpp

@@ -3,10 +3,11 @@
 #include <queue>
 #include <string>
 #include <unordered_set>
+#include <variant>
+#include "GraphEdge.hpp"
 #include "AdjacencyList.hpp"
 #include "AdjacencyMatrix.hpp"
 
-
 static PyObject* breadth_first_search_adjacency_list(PyObject* self, PyObject* args, PyObject* kwargs) {
     PyObject* graph_obj;
     const char* source_name;
@@ -153,3 +154,111 @@ static PyObject* breadth_first_search_adjacency_matrix(PyObject* self, PyObject*
 
     Py_RETURN_NONE;
 }
+
+static PyObject* minimum_spanning_tree_prim_adjacency_list(PyObject* self, PyObject* args, PyObject* kwargs) {
+
+    PyObject* graph_obj;
+    static const char* kwlist[] = {"graph", nullptr};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", const_cast<char**>(kwlist),
+                                     &AdjacencyListGraphType, &graph_obj)) {
+        return nullptr;
+    }
+
+    AdjacencyListGraph* graph = reinterpret_cast<AdjacencyListGraph*>(graph_obj);
+
+    struct EdgeTuple {
+        std::string source;
+        std::string target;
+        std::variant<std::monostate, int64_t, double, std::string> value;
+        DataType value_type;
+
+        bool operator>(const EdgeTuple& other) const {
+            if (value_type != other.value_type)
+                return value_type > other.value_type;
+            if (std::holds_alternative<int64_t>(value))
+                return std::get<int64_t>(value) > std::get<int64_t>(other.value);
+            if (std::holds_alternative<double>(value))
+                return std::get<double>(value) > std::get<double>(other.value);
+            if (std::holds_alternative<std::string>(value))
+                return std::get<std::string>(value) > std::get<std::string>(other.value);
+            return false;
+        }
+    };
+
+    std::priority_queue<EdgeTuple, std::vector<EdgeTuple>, std::greater<>> pq;
+    std::unordered_set<std::string> visited;
+
+    PyObject* mst_graph = PyObject_CallObject(reinterpret_cast<PyObject*>(&AdjacencyListGraphType), nullptr);
+    AdjacencyListGraph* mst = reinterpret_cast<AdjacencyListGraph*>(mst_graph);
+
+    std::string start = graph->node_map.begin()->first;
+    visited.insert(start);
+
+    AdjacencyListGraphNode* start_node = graph->node_map[start];
+
+    Py_INCREF(start_node);
+    mst->nodes.push_back(start_node);
+    mst->node_map[start] = start_node;
+
+    for (const auto& [adj_name, _] : start_node->adjacent) {
+        std::string key = make_edge_key(start, adj_name);
+        GraphEdge* edge = graph->edges[key];
+        pq.push({start, adj_name, edge->value, edge->value_type});
+    }
+
+    while (!pq.empty()) {
+        EdgeTuple edge = pq.top();
+        pq.pop();
+
+        if (visited.count(edge.target)) continue;
+        visited.insert(edge.target);
+
+        for (const std::string& name : {edge.source, edge.target}) {
+            if (!mst->node_map.count(name)) {
+                AdjacencyListGraphNode* node = graph->node_map[name];
+                Py_INCREF(node);
+                mst->nodes.push_back(node);
+                mst->node_map[name] = node;
+            }
+        }
+
+        AdjacencyListGraphNode* u = mst->node_map[edge.source];
+        AdjacencyListGraphNode* v = mst->node_map[edge.target];
+
+        Py_INCREF(v);
+        Py_INCREF(u);
+        u->adjacent[edge.target] = reinterpret_cast<PyObject*>(v);
+        v->adjacent[edge.source] = reinterpret_cast<PyObject*>(u);
+
+        std::string key_uv = make_edge_key(edge.source, edge.target);
+        GraphEdge* new_edge = PyObject_New(GraphEdge, &GraphEdgeType);
+        Py_INCREF(u);
+        Py_INCREF(v);
+        new_edge->source = reinterpret_cast<PyObject*>(u);
+        new_edge->target = reinterpret_cast<PyObject*>(v);
+        new (&new_edge->value) std::variant<std::monostate, int64_t, double, std::string>(edge.value);
+        new_edge->value_type = edge.value_type;
+        mst->edges[key_uv] = new_edge;
+
+        std::string key_vu = make_edge_key(edge.target, edge.source);
+        GraphEdge* new_edge_rev = PyObject_New(GraphEdge, &GraphEdgeType);
+        new_edge_rev->source = reinterpret_cast<PyObject*>(v);
+        new_edge_rev->target = reinterpret_cast<PyObject*>(u);
+        new (&new_edge_rev->value) std::variant<std::monostate, int64_t, double, std::string>(edge.value);
+        new_edge_rev->value_type = edge.value_type;
+        mst->edges[key_vu] = new_edge_rev;
+
+        AdjacencyListGraphNode* next_node = graph->node_map[edge.target];
+
+        for (const auto& [adj_name, _] : next_node->adjacent) {
+            if (visited.count(adj_name)) continue;
+            std::string key = make_edge_key(edge.target, adj_name);
+            GraphEdge* adj_edge = graph->edges[key];
+            pq.push({edge.target, adj_name, adj_edge->value, adj_edge->value_type});
+        }
+    }
+
+    Py_INCREF(mst);
+    return reinterpret_cast<PyObject*>(mst);
+}

pydatastructs/graphs/_backend/cpp/algorithms.cpp

@@ -6,6 +6,7 @@
 static PyMethodDef AlgorithmsMethods[] = {
     {"bfs_adjacency_list", (PyCFunction)breadth_first_search_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency list with callback"},
     {"bfs_adjacency_matrix", (PyCFunction)breadth_first_search_adjacency_matrix, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency matrix with callback"},
+    {"minimum_spanning_tree_prim_adjacency_list", (PyCFunction)minimum_spanning_tree_prim_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run Prim's algorithm on adjacency list"},
     {NULL, NULL, 0, NULL}
 };
 

pydatastructs/graphs/algorithms.py

@@ -338,16 +338,20 @@ def minimum_spanning_tree(graph, algorithm, **kwargs):
     should be used only for such graphs. Using with other
     types of graphs may lead to unwanted results.
     """
-    raise_if_backend_is_not_python(
-        minimum_spanning_tree, kwargs.get('backend', Backend.PYTHON))
-    import pydatastructs.graphs.algorithms as algorithms
-    func = "_minimum_spanning_tree_" + algorithm + "_" + graph._impl
-    if not hasattr(algorithms, func):
-        raise NotImplementedError(
-        "Currently %s algoithm for %s implementation of graphs "
-        "isn't implemented for finding minimum spanning trees."
-        %(algorithm, graph._impl))
-    return getattr(algorithms, func)(graph)
+    backend = kwargs.get('backend', Backend.PYTHON)
+    if backend == Backend.PYTHON:
+        import pydatastructs.graphs.algorithms as algorithms
+        func = "_minimum_spanning_tree_" + algorithm + "_" + graph._impl
+        if not hasattr(algorithms, func):
+            raise NotImplementedError(
+            "Currently %s algoithm for %s implementation of graphs "
+            "isn't implemented for finding minimum spanning trees."
+            %(algorithm, graph._impl))
+        return getattr(algorithms, func)(graph)
+    else:
+        from pydatastructs.graphs._backend.cpp._algorithms import minimum_spanning_tree_prim_adjacency_list
+        if graph._impl == "adjacency_list" and algorithm == 'prim':
+            return minimum_spanning_tree_prim_adjacency_list(graph)
 
 def _minimum_spanning_tree_parallel_kruskal_adjacency_list(graph, num_threads):
     mst = _generate_mst_object(graph)

pydatastructs/graphs/tests/test_adjacency_list.py

@@ -67,16 +67,16 @@ def test_adjacency_list():
     g2.add_vertex(v)
     g2.add_edge('v_4', 'v', 0)
     g2.add_edge('v_5', 'v', 0)
-    g2.add_edge('v_6', 'v', 0)
+    g2.add_edge('v_6', 'v', "h")
     assert g2.is_adjacent('v_4', 'v') is True
     assert g2.is_adjacent('v_5', 'v') is True
     assert g2.is_adjacent('v_6', 'v') is True
     e1 = g2.get_edge('v_4', 'v')
     e2 = g2.get_edge('v_5', 'v')
     e3 = g2.get_edge('v_6', 'v')
-    assert (str(e1)) == "('v_4', 'v')"
-    assert (str(e2)) == "('v_5', 'v')"
-    assert (str(e3)) == "('v_6', 'v')"
+    assert (str(e1)) == "('v_4', 'v', 0)"
+    assert (str(e2)) == "('v_5', 'v', 0)"
+    assert (str(e3)) == "('v_6', 'v', h)"
     g2.remove_edge('v_4', 'v')
     assert g2.is_adjacent('v_4', 'v') is False
     g2.remove_vertex('v')

pydatastructs/graphs/tests/test_algorithms.py

@@ -185,6 +185,33 @@ def _test_minimum_spanning_tree(func, ds, algorithm, *args):
         for k, v in mst.edge_weights.items():
             assert (k, v.value) in expected_mst
 
+    def _test_minimum_spanning_tree_cpp(ds, algorithm, *args):
+        if (ds == 'List' and algorithm == "prim"):
+            a1 = AdjacencyListGraphNode('a',0, backend = Backend.CPP)
+            b1 = AdjacencyListGraphNode('b',0, backend = Backend.CPP)
+            c1 = AdjacencyListGraphNode('c',0, backend = Backend.CPP)
+            d1 = AdjacencyListGraphNode('d',0, backend = Backend.CPP)
+            e1 = AdjacencyListGraphNode('e',0, backend = Backend.CPP)
+            g = Graph(a1, b1, c1, d1, e1, backend = Backend.CPP)
+            g.add_edge(a1.name, c1.name, 10)
+            g.add_edge(c1.name, a1.name, 10)
+            g.add_edge(a1.name, d1.name, 7)
+            g.add_edge(d1.name, a1.name, 7)
+            g.add_edge(c1.name, d1.name, 9)
+            g.add_edge(d1.name, c1.name, 9)
+            g.add_edge(d1.name, b1.name, 32)
+            g.add_edge(b1.name, d1.name, 32)
+            g.add_edge(d1.name, e1.name, 23)
+            g.add_edge(e1.name, d1.name, 23)
+            mst = minimum_spanning_tree(g, "prim", backend = Backend.CPP)
+            expected_mst = ["('a', 'd', 7)", "('d', 'c', 9)", "('e', 'd', 23)", "('b', 'd', 32)",
+                        "('d', 'a', 7)", "('c', 'd', 9)", "('d', 'e', 23)", "('d', 'b', 32)"]
+            assert str(mst.get_edge('a','d')) in expected_mst
+            assert str(mst.get_edge('e','d')) in expected_mst
+            assert str(mst.get_edge('d','c')) in expected_mst
+            assert str(mst.get_edge('b','d')) in expected_mst
+            assert mst.num_edges() == 8
+
     fmst = minimum_spanning_tree
     fmstp = minimum_spanning_tree_parallel
     _test_minimum_spanning_tree(fmst, "List", "kruskal")
@@ -193,6 +220,7 @@ def _test_minimum_spanning_tree(func, ds, algorithm, *args):
     _test_minimum_spanning_tree(fmstp, "List", "kruskal", 3)
     _test_minimum_spanning_tree(fmstp, "Matrix", "kruskal", 3)
     _test_minimum_spanning_tree(fmstp, "List", "prim", 3)
+    _test_minimum_spanning_tree_cpp("List", "prim")
 
 def test_strongly_connected_components():
 

pydatastructs/utils/_backend/cpp/GraphEdge.hpp

@@ -4,6 +4,7 @@
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <string>
+#include <variant>
 #include "GraphNode.hpp"
 
 extern PyTypeObject GraphEdgeType;
@@ -12,56 +13,123 @@ typedef struct {
     PyObject_HEAD
     PyObject* source;
     PyObject* target;
-    PyObject* value;
+    std::variant<std::monostate, int64_t, double, std::string> value;
+    DataType value_type;
 } GraphEdge;
 
 static void GraphEdge_dealloc(GraphEdge* self) {
     Py_XDECREF(self->source);
     Py_XDECREF(self->target);
-    Py_XDECREF(self->value);
     Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
 }
 
 static PyObject* GraphEdge_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
-    GraphEdge* self;
-    self = reinterpret_cast<GraphEdge*>(type->tp_alloc(type, 0));
+    GraphEdge* self = PyObject_New(GraphEdge, &GraphEdgeType);
     if (!self) return NULL;
 
+    new (&self->value) std::variant<std::monostate, int64_t, double, std::string>();
+    self->value_type = DataType::None;
+
     static char* kwlist[] = {"node1", "node2", "value", NULL};
     PyObject* node1;
     PyObject* node2;
     PyObject* value = Py_None;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist, &node1, &node2, &value)) {
-        PyErr_SetString(PyExc_ValueError, "Invalid arguments: Expected (GraphNode, GraphNode, optional value)");
+        PyErr_SetString(PyExc_ValueError, "Expected (GraphNode, GraphNode, optional value)");
         return NULL;
     }
 
     Py_INCREF(node1);
     Py_INCREF(node2);
-    Py_INCREF(value);
-
     self->source = node1;
     self->target = node2;
-    self->value = value;
+
+    if (value == Py_None) {
+        self->value_type = DataType::None;
+        self->value = std::monostate{};
+    } else if (PyLong_Check(value)) {
+        self->value_type = DataType::Int;
+        self->value = static_cast<int64_t>(PyLong_AsLongLong(value));
+    } else if (PyFloat_Check(value)) {
+        self->value_type = DataType::Double;
+        self->value = PyFloat_AsDouble(value);
+    } else if (PyUnicode_Check(value)) {
+        const char* str = PyUnicode_AsUTF8(value);
+        self->value_type = DataType::String;
+        self->value = std::string(str);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "Unsupported edge value type (must be int, float, str, or None)");
+        return NULL;
+    }
 
     return reinterpret_cast<PyObject*>(self);
 }
 
 static PyObject* GraphEdge_str(GraphEdge* self) {
-    std::string source_name = (reinterpret_cast<GraphNode*>(self->source))->name;
-    std::string target_name = (reinterpret_cast<GraphNode*>(self->target))->name;
-
-    if (source_name.empty() || target_name.empty()) {
-        PyErr_SetString(PyExc_AttributeError, "Both nodes must have a 'name' attribute.");
-        return NULL;
+    std::string src = reinterpret_cast<GraphNode*>(self->source)->name;
+    std::string tgt = reinterpret_cast<GraphNode*>(self->target)->name;
+    std::string val_str;
+
+    switch (self->value_type) {
+        case DataType::Int:
+            val_str = std::to_string(std::get<int64_t>(self->value));
+            break;
+        case DataType::Double:
+            val_str = std::to_string(std::get<double>(self->value));
+            break;
+        case DataType::String:
+            val_str = std::get<std::string>(self->value);
+            break;
+        case DataType::None:
+        default:
+            val_str = "None";
+            break;
     }
 
-    PyObject* str_repr = PyUnicode_FromFormat("('%s', '%s')", source_name.c_str(), target_name.c_str());
+    return PyUnicode_FromFormat("('%s', '%s', %s)", src.c_str(), tgt.c_str(), val_str.c_str());
+}
 
-    return str_repr;
+static PyObject* GraphEdge_get_value(GraphEdge* self, void* closure) {
+    switch (self->value_type) {
+        case DataType::Int:
+            return PyLong_FromLongLong(std::get<int64_t>(self->value));
+        case DataType::Double:
+            return PyFloat_FromDouble(std::get<double>(self->value));
+        case DataType::String:
+            return PyUnicode_FromString(std::get<std::string>(self->value).c_str());
+        case DataType::None:
+        default:
+            Py_RETURN_NONE;
+    }
 }
 
+static int GraphEdge_set_value(GraphEdge* self, PyObject* value) {
+    if (value == Py_None) {
+        self->value_type = DataType::None;
+        self->value = std::monostate{};
+    } else if (PyLong_Check(value)) {
+        self->value_type = DataType::Int;
+        self->value = static_cast<int64_t>(PyLong_AsLongLong(value));
+    } else if (PyFloat_Check(value)) {
+        self->value_type = DataType::Double;
+        self->value = PyFloat_AsDouble(value);
+    } else if (PyUnicode_Check(value)) {
+        const char* str = PyUnicode_AsUTF8(value);
+        self->value_type = DataType::String;
+        self->value = std::string(str);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "Edge value must be int, float, str, or None.");
+        return -1;
+    }
+    return 0;
+}
+
+static PyGetSetDef GraphEdge_getsetters[] = {
+    {"value", (getter)GraphEdge_get_value, (setter)GraphEdge_set_value, "Get or set edge value", NULL},
+    {NULL}
+};
+
 inline PyTypeObject GraphEdgeType = {
     /* tp_name */ PyVarObject_HEAD_INIT(NULL, 0) "GraphEdge",
     /* tp_basicsize */ sizeof(GraphEdge),

pydatastructs/utils/tests/test_misc_util.py

@@ -53,7 +53,7 @@ def test_GraphEdge():
     h_1 = AdjacencyListGraphNode('h_1', 1, backend = Backend.CPP)
     h_2 = AdjacencyListGraphNode('h_2', 2, backend = Backend.CPP)
     e2 = GraphEdge(h_1, h_2, value = 2, backend = Backend.CPP)
-    assert str(e2) == "('h_1', 'h_2')"
+    assert str(e2) == "('h_1', 'h_2', 2)"
 
 def test_BinomialTreeNode():
     b = BinomialTreeNode(1,1)