1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/// Containing algorithms that can get executed on graphs and subgraphs. /// /// Graphs and subgraphs expose some functionalities defined in the [`provide`](crate::provide) module. /// One the other end, each algorithm defined in this module require some of the functionalities defined in [`provide`](crate::provide) to be able to get executed. /// So for one algorithm to be executable on a specific graph or subgraph, it is necessary for the graphs exposed functionalities to match the requirements of the algorithm. pub mod algo; /// Re-exports traits and structs that are necessary to accomplish basic tasks with prepona. pub mod prelude; /// Graphs sit on top of storages defined in [`storage`](crate::storage) module and provide logic about how a storage should be used. /// /// For example [`SimpleGraph`](crate::graph::SimpleGraph) makes sure that no more than one edge is added between two vertices. /// It also prevents from adding loops to graph. For more information checkout [`SimpleGraph`](crate::graph::SimpleGraph) documentation. pub mod graph; /// Collection of traits that each define a set of functionalities exposed by a graph. /// /// Algorithms only depend on functionalities that are defined in this module and not on specific structures like graphs. /// This enables us to decouple algorithms from data structures that they receive as input. /// So you can define your own structure wether it's a graph, subgraph or an augmented graph and run algorithms defined in `algo` module on them. /// All you have to do is to implement the traits that are needed by the algorithm you want to use. /// /// # Note /// Functions defined in each trait are abstractions of what is expected from the graphs that implement them. /// For concrete information about why/when these functions may panic or return `Err`, refer to the specific graph struct that you are using. pub mod provide; /// Storages are structures that graphs use to store information about vertices and edges. /// /// There are two storage types that are supported: /// * Adjacency matrix: Is a matrix used to represent a finite graph. /// The elements of the matrix indicate whether pairs of vertices are adjacent or not in the graph. /// For more info read [`AdjMatrix`](crate::storage::AdjMatrix). /// * Adjacency list: Is a collection of unordered lists used to represent a finite graph. /// Each list describes the set of neighbors of a vertex in the graph. /// For more info read [`AdjList`](crate::storage::AdjList) /// /// Each storage must implement the [`GraphStorage`](crate::storage::GraphStorage) trait. /// So You can create your own storage and after implementing the `GraphStorage`, pass it to the graph to use it as backend storage of the graph. /// /// For a more informed decision regarding to which storage to choose, checkout documentation of each storage and compare their memory usage and time complexity of each operation. pub mod storage;