added cpp backend for dfs and bellman ford algorithms

Author: Prerak Singh

install/lib/python3.12/site-packages/pydatastructs/__init__.py

@@ -0,0 +1,8 @@
+from .utils import *
+from .linear_data_structures import *
+from .trees import *
+from .miscellaneous_data_structures import *
+from .graphs import *
+from .strings import *
+
+__version__ = "1.0.1-dev"

install/lib/python3.12/site-packages/pydatastructs/graphs/__init__.py

@@ -0,0 +1,28 @@
+__all__ = []
+
+from . import graph
+from .graph import (
+    Graph
+)
+__all__.extend(graph.__all__)
+
+from . import algorithms
+from . import adjacency_list
+from . import adjacency_matrix
+
+from .algorithms import (
+    breadth_first_search,
+    breadth_first_search_parallel,
+    minimum_spanning_tree,
+    minimum_spanning_tree_parallel,
+    strongly_connected_components,
+    depth_first_search,
+    shortest_paths,
+    all_pair_shortest_paths,
+    topological_sort,
+    topological_sort_parallel,
+    max_flow,
+    find_bridges
+)
+
+__all__.extend(algorithms.__all__)

install/lib/python3.12/site-packages/pydatastructs/graphs/_backend/__init__.py

@@ -0,0 +1,101 @@
+from pydatastructs.graphs.graph import Graph
+from pydatastructs.graphs._backend.cpp import _graph
+from pydatastructs.utils.misc_util import (
+    GraphEdge, Backend, raise_if_backend_is_not_python)
+
+__all__ = [
+    'AdjacencyList'
+]
+
+class AdjacencyList(Graph):
+    """
+    Adjacency list implementation of graphs.
+
+    See also
+    ========
+
+    pydatastructs.graphs.graph.Graph
+    """
+    def __new__(cls, *vertices, **kwargs):
+
+        backend = kwargs.get('backend', Backend.PYTHON)
+        if backend == Backend.PYTHON:
+            obj = object.__new__(cls)
+            for vertex in vertices:
+                obj.__setattr__(vertex.name, vertex)
+            obj.vertices = [vertex.name for vertex in vertices]
+            obj.edge_weights = {}
+            obj._impl = 'adjacency_list'
+            return obj
+        else:
+            graph = _graph.AdjacencyListGraph()
+            for vertice in vertices:
+                graph.add_vertex(vertice)
+            return graph
+
+    @classmethod
+    def methods(self):
+        return ['is_adjacent', 'neighbors',
+                'add_vertex', 'remove_vertex', 'add_edge',
+                'get_edge', 'remove_edge', '__new__']
+
+    def is_adjacent(self, node1, node2):
+        node1 = self.__getattribute__(node1)
+        return hasattr(node1, node2)
+
+    def num_vertices(self):
+        return len(self.vertices)
+
+    def num_edges(self):
+        return sum(len(self.neighbors(v)) for v in self.vertices)
+
+    def neighbors(self, node):
+        node = self.__getattribute__(node)
+        return [self.__getattribute__(name) for name in node.adjacent]
+
+    def add_vertex(self, node):
+        if not hasattr(self, node.name):
+            self.vertices.append(node.name)
+            self.__setattr__(node.name, node)
+
+    def remove_vertex(self, name):
+        delattr(self, name)
+        self.vertices.remove(name)
+        for node in self.vertices:
+            node_obj = self.__getattribute__(node)
+            if hasattr(node_obj, name):
+                delattr(node_obj, name)
+                node_obj.adjacent.remove(name)
+
+    def add_edge(self, source, target, cost=None):
+        source, target = str(source), str(target)
+        error_msg = ("Vertex %s is not present in the graph."
+                     "Call Graph.add_vertex to add a new"
+                     "vertex. Graph.add_edge is only responsible"
+                     "for adding edges and it will not add new"
+                     "vertices on its own. This is done to maintain"
+                     "clear separation between the functionality of"
+                     "these two methods.")
+        if not hasattr(self, source):
+            raise ValueError(error_msg % (source))
+        if not hasattr(self, target):
+            raise ValueError(error_msg % (target))
+
+        source, target = self.__getattribute__(source), \
+            self.__getattribute__(target)
+        source.add_adjacent_node(target.name)
+        if cost is not None:
+            self.edge_weights[source.name + "_" + target.name] = \
+                GraphEdge(source, target, cost)
+
+    def get_edge(self, source, target):
+        return self.edge_weights.get(
+            source + "_" + target,
+            None)
+
+    def remove_edge(self, source, target):
+        source, target = self.__getattribute__(source), \
+                         self.__getattribute__(target)
+        source.remove_adjacent_node(target.name)
+        self.edge_weights.pop(source.name + "_" + target.name,
+                                None)

install/lib/python3.12/site-packages/pydatastructs/graphs/adjacency_list.py

@@ -0,0 +1,100 @@
+from pydatastructs.graphs.graph import Graph
+from pydatastructs.graphs._backend.cpp import _graph
+from pydatastructs.utils.misc_util import (
+    GraphEdge, raise_if_backend_is_not_python,
+    Backend)
+
+__all__ = [
+    'AdjacencyMatrix'
+]
+
+class AdjacencyMatrix(Graph):
+    """
+    Adjacency matrix implementation of graphs.
+
+    See also
+    ========
+
+    pydatastructs.graphs.graph.Graph
+    """
+    def __new__(cls, *vertices, **kwargs):
+        backend = kwargs.get('backend', Backend.PYTHON)
+        if backend == Backend.PYTHON:
+            obj = object.__new__(cls)
+            obj.vertices = [vertex.name for vertex in vertices]
+            for vertex in vertices:
+                obj.__setattr__(vertex.name, vertex)
+            obj.matrix = {}
+            for vertex in vertices:
+                obj.matrix[vertex.name] = {}
+            obj.edge_weights = {}
+            obj._impl = 'adjacency_matrix'
+            return obj
+        else:
+            return _graph.AdjacencyMatrixGraph(vertices)
+
+    @classmethod
+    def methods(self):
+        return ['is_adjacent', 'neighbors',
+        'add_edge', 'get_edge', 'remove_edge',
+        '__new__']
+
+    def is_adjacent(self, node1, node2):
+        node1, node2 = str(node1), str(node2)
+        row = self.matrix.get(node1, {})
+        return row.get(node2, False) is not False
+
+    def num_vertices(self):
+        return len(self.vertices)
+
+    def num_edges(self):
+        return sum(len(v) for v in self.matrix.values())
+
+    def neighbors(self, node):
+        node = str(node)
+        neighbors = []
+        row = self.matrix.get(node, {})
+        for node, presence in row.items():
+            if presence:
+                neighbors.append(self.__getattribute__(
+                                 str(node)))
+        return neighbors
+
+    def add_vertex(self, node):
+        raise NotImplementedError("Currently we allow "
+                "adjacency matrix for static graphs only")
+
+    def remove_vertex(self, node):
+        raise NotImplementedError("Currently we allow "
+                "adjacency matrix for static graphs only.")
+
+    def add_edge(self, source, target, cost=None):
+        source, target = str(source), str(target)
+        error_msg = ("Vertex %s is not present in the graph."
+                     "Call Graph.add_vertex to add a new"
+                     "vertex. Graph.add_edge is only responsible"
+                     "for adding edges and it will not add new"
+                     "vertices on its own. This is done to maintain"
+                     "clear separation between the functionality of"
+                     "these two methods.")
+        if source not in self.matrix:
+            raise ValueError(error_msg % (source))
+        if target not in self.matrix:
+            raise ValueError(error_msg % (target))
+
+        self.matrix[source][target] = True
+        if cost is not None:
+            self.edge_weights[source + "_" + target] = \
+                GraphEdge(self.__getattribute__(source),
+                          self.__getattribute__(target),
+                          cost)
+
+    def get_edge(self, source, target):
+        return self.edge_weights.get(
+            str(source) + "_" + str(target),
+            None)
+
+    def remove_edge(self, source, target):
+        source, target = str(source), str(target)
+        self.matrix[source][target] = False
+        self.edge_weights.pop(str(source) + "_" + str(target), None)