Erdos alternatives and similar libraries
Based on the "Science" category.
Alternatively, view Erdos alternatives based on common mentions on social networks and blogs.

JGraphX
Library for visualisation (mainly Swing) and interaction with nodeedge graphs. 
JScience
Provides a set of classes to work with scientific measurements and units. 
DataMelt
Environment for scientific computation, data analysis and data visualization.
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Erdos or a related project?
Popular Comparisons
README
Erdos is a very light, modular and super easy to use modern Graph theoretic algorithms framework for Java
. It
contains graph algorithms that you can apply swiftly with one line of code and was primarily developed to back a worker
manager tasks for various Java projects including one in Android.
Erdos was born because other frameworks in Java were very hard to get started with or just plain heavy (overhead wise) or just too opinionated. Erdos let the developer design it's own graph engines to optimise the runtime and comes with all of the graph algorithms you can expect.
How to use
Option 1: Jitpack
Add Jitpack in your root build.gradle at the end of repositories:
allprojects {
repositories {
...
maven { url "https://jitpack.io" }
}
}
Add to your dependencies:
dependencies {
compile 'com.github.ErdosGraphFramework:Erdos:v1.0'
// or the following for the current master snapshot
// compile 'com.github.ErdosGraphFramework:Erdos:masterSNAPSHOT'
}
Option 2: Simply fork or download the project, you can also download and create .jar
file yourself, with
git clone https://github.com/ErdosGraphFramework/Erdos.git erdos
cd erdos
./gradlew build
ls l build/libs
Option 3: grab the latest released jar
https://github.com/ErdosGraphFramework/Erdos/releases
Notable technical features
 compatible with
Java 7
 compose your graph by features and engine. modular design.
 production proved code. Used in a commercial project.
Supported graphs
 simple graph, directed and undirected
 multi edge graph, directed and undirected
 pseudo graph
 custom graph, configure by selfloops, multiedges and a graph engine.
builtin algorithms
Erdos is a framework to easily help you design graph algorithms with the correct abstractions and utilities. The builtin algorithms are:
 search algorithms
 sorting
 structure
 minimum spanning tree
 single source shortest path
 Bellman–Ford algorithm
 Dijkstra's algorithm
 Directed acyclic graph algorithm
 all pairs shortest path
 minimum spanning tree
 transformations
 Square of a graph
 transitive closure of a graph
 transpose of a graph
builtin graph engines
 Adjacency and Incidence list based graph engine designed for optimal complexity for algorithms that require more than a moderate edge queries.
 in the future, a adjacency matrix engine will be added. That will be good to certain types of graphs, where queries are small, and memory should be kept as small as possible.
 you can add your own graph engine by implementing
AbstractGraphEngine
.
Instructions, code by examples
1. creating a very simple graph
SimpleDirectedGraph graph_triangle = new SimpleDirectedGraph();
Vertex v0 = new Vertex();
Vertex v1 = new Vertex();
Vertex v2 = new Vertex("tag_v2");
graph_triangle.addVertex(v0);
graph_triangle.addVertex(v1);
graph_triangle.addVertex(v2);
Edge e_0 = graph_triangle.addEdge(v0, v1);
graph_triangle.addEdge(v1, v2);
graph_triangle.addEdge(v2, v3);
graph_triangle.print();
// iterate the graph vertices directly
for (IVertex vertex : graph_triangle) {
System.out.println(vertex.toString());
}
// iterate the edges of the graph
for (Edge edge : graph_triangle.edges()) {
System.out.println(edge.toString());
}
// removing a vertex in any of the following ways will remove it's connected edges as well,
// also removing any edge in similar fashion will update the graph :)
graph_triangle.removeVertex(v0);
graph_triangle.vertices().remove(v1);
graph_triangle.vertices().iterator().remove();
2. use a factory for custom graph
you can define your graph in terms of self loops, multi edges (per vertex) and a custom implementation of a graph engine.
boolean allow_self_loops = true;
boolean allow_multi_edges = true;
UndirectedGraph graph_undirected = Erdos.newUndirectedGraphWithEngine(new AdjIncidenceGraphEngine(),
allow_self_loops, allow_multi_edges);
DirectedGraph graph = Erdos.newGraphWithEngine(new AdjIncidenceGraphEngine(),
Edge.EDGE_DIRECTION.DIRECTED,
allow_self_loops, allow_multi_edges);
3. algorithms introduction
every algorithm extends AbstractGraphAlgorithm<T, E extends IGraph>
, which is generically
typed E
for input graph and T
for output and must implement
T applyAlgorithm()
method
for example, the BellmanFord
algorithm for single source shortest path,
followed by the FloydWarshall
algorithm for all pairs shortest paths.
private void BellmanFord()
{
SimpleDirectedGraph graph = new SimpleDirectedGraph();
Vertex s = new Vertex("s");
Vertex t = new Vertex("t");
Vertex x = new Vertex("x");
Vertex y = new Vertex("y");
Vertex z = new Vertex("z");
graph.addVertex(s);
graph.addVertex(t);
graph.addVertex(x);
graph.addVertex(y);
graph.addVertex(z);
graph.addEdge(s, t, 6);
graph.addEdge(t, x, 5);
graph.addEdge(x, t, 2);
graph.addEdge(s, y, 7);
graph.addEdge(y, z, 9);
graph.addEdge(t, y, 8);
graph.addEdge(z, x, 7);
graph.addEdge(t, z, 4);
graph.addEdge(y, x, 3);
graph.addEdge(z, s, 2);
graph.setTag("graph");
graph.print();
// apply the BellmanFord algorithm
ShortestPathsTree res = new BellmanFordShortestPath(graph).setStartVertex(s).applyAlgorithm();
// print it
res.print();
// apply the FloydWarshall algorithm
AllPairsShortPathResult floyd_result = new FloydWarshall(graph).applyAlgorithm();
// print the shortest paths tree of the vertex
floyd_result.shortestPathsTreeOf(s).print();
// print the shortest path between two nodes
System.out.println(floyd_result.shortestPathBetween(s, z).toString());
}
4. algorithms, more examples
this example shows the simplicity of the framework (hopefully ;)) where we apply 5 different algorithms sequentally
// perform a breadth first search
BFS.BreadthFirstTree breadthFirstTree = new BFS(graph, s).applyAlgorithm();
// perform a depth first search
DFS.DepthFirstForest depthFirstForest = new DFS(graph).applyAlgorithm();
// extract the strongly connected components of the graph
ArrayList<HashSet<IVertex>> hashSets = new SCC(graph).applyAlgorithm();
// perform a topological sort on the graph
LinkedList<IVertex> res_sort = new TopologicalSort(graph).applyAlgorithm();
// compute all pairs shortest paths using the FloydWarshall algorithm
AllPairsShortPathResult floyd_result = new FloydWarshall(graph).applyAlgorithm();
5. algorithms factories
for major algorithms types, you can comfortably use the following algorithms factories
MinSpanTreeFactory
 for Minimum Spanning Tree/Forest, for example:java AbstractGraphAlgorithm<UndirectedGraph, IUndirectedGraph> alg = MinSpanTreeFactory.newMST(graph, MstAlgorithm.KRUSKAL, start_vertex); AbstractGraphAlgorithm<UndirectedGraph, IUndirectedGraph> alg2 = MinSpanTreeFactory.newMST(graph, MstAlgorithm.PRIM, start_vertex);
SingleSourceShortPathFactory
 for single source shortest path, for example:java AbstractShortestPathAlgorithm alg = SingleSourceShortPathFactory.newSingleSourceShortPath(graph, SSSPAlgorithm.DIJKSTRA, start_vertex, end_vertex);
AllPairsShortPathFactory
 for shortest paths between all pairs, for example:java AbstractGraphAlgorithm<AllPairsShortPathResult, IDirectedGraph> alg2 = AllPairsShortPathFactory.newAllPairsShortPath(graph, APSPAlgorithm.Johnson);
``#### 6. utilities a bunch of helper utilities can be found in the package **
com.hendrix.erdos.utils`**SVertexUtils.java
 query vertex order information inside a graphSEdgeUtils.java
 query edge order information inside a graphSMatrixUtils.java
 compute the adjacency and incidence matrix of a graphSGraphUtils.java
 get a sorted list of the weighted edges in a graph
used in
AndroidZorn
 for constructing a worker manager based on topological sorting in a graph.
Contributions
contributions are most welcomed, please consult [CONTRIBUTING.md
](CONTRIBUTING.md)
what is the Erdős ?
homage to the great hungarian mathmatician Paul Erdős
who part of his research was rooted in combinatorial graph theory.
License
If you like it > star or share it with others
MIT License
Copyright (c) 2017 Tomer Shalev and Erdos (https://github.com/HendrixString)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Contact Author
*Note that all licence references and agreements mentioned in the Erdos README section above
are relevant to that project's source code only.