Der Artikel "Eine vergleichende Bewertung von Werkzeugen zur Analyse sozialer Netzwerke: Perspektiven der Leistung und des Engagements in der Gemeinschaft" geht der entscheidenden Rolle der Graphenanalyse beim Verständnis komplexer Beziehungen und Strukturen in verschiedenen Bereichen nach. Es untersucht die Leistung weit verbreiteter Diagrammanalysewerkzeuge wie NetworkX, EasyGraph, Rustworkx, Graph-tool und Igraph und vergleicht sie anhand verschiedener Netzwerkanalysemethoden und Datensätze. Die Studie hebt die Rechengeschwindigkeit und die Kennzahlen für das Engagement der Gemeinschaft dieser Werkzeuge hervor und bietet wertvolle Erkenntnisse für Praktiker und Forscher. Die Ergebnisse zeigen, dass Igraph und Graph-Tool die vielseitigsten und effizientesten Tools sind, während EasyGraph sich bei der Community-Erkennung und den damit verbundenen Komponenten hervortut. Obwohl NetworkX populär ist, hinkt es bei der Rechenleistung hinterher. Der Artikel schließt mit der Betonung der Wichtigkeit, sowohl Leistung als auch Benutzerfreundlichkeit bei der Auswahl von Netzwerkanalyse-Tools zu berücksichtigen und eine klare, vergleichende Analyse zu liefern, um informierte Entscheidungsfindung zu ermöglichen.
KI-Generiert
Diese Zusammenfassung des Fachinhalts wurde mit Hilfe von KI generiert.
Abstract
Graphs are increasingly used in research, industry, and government. This has led to a wide range of analytical and graph-processing tools. There are various tools and platforms for graph processing. Over time, diverse systems have emerged, employing various statistics and criteria to evaluate their effectiveness and usability in processing graph data. As a result, comparing the various systems’ performances becomes challenging. This study benchmarks popular network analysis tools—NetworkX, RustworkX, Igraph, EasyGraph, and Graph-tool—by evaluating their performance and extracted community engagement metrics, such as the number of downloads, stars, and forks which reflect the tools’ adoption, popularity, and community support. We benchmark the library’s performance on four open-source datasets, one custom dataset, and twelve network analysis methods. The findings reveal that while NetworkX is highly popular, it exhibits slower performance in most benchmarks compared to Graph-tool and Igraph, which are faster and more efficient despite their lower popularity. The continued popularity of NetworkX may be attributed to factors like well-documented methods and a user-friendly API, though this warrants further investigation. This research provides valuable insights for practitioners, researchers, and developers, helping them make informed decisions when selecting network analysis tools. The study emphasizes the trade-off between user-friendliness and performance, suggesting that the optimal tool choice depends on project-specific requirements.
Hinweise
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
1 Introduction
Graph analysis is fundamental for understanding complex relationships and structures in various fields, including social networks, biological networks, transportation systems and complex citation networks. Graph analysis makes applications like targeted marketing, misinformation detection, and social behavior modeling possible, making it easier to analyze community (Brandes 2001), influence propagation, and social dynamics (Akinnubi et al. 2024; Şen et al. 2016; Alassad and Agarwal 2023) in social networks.
Graph analysis is a versatile and indispensable tool across various domains, offering profound insights and enabling significant advancements. In the field of systems biology, it plays a pivotal role in unraveling the complexities of metabolic pathways, gene regulatory networks, and protein–protein interactions, thereby driving progress in systems biology and drug discovery (Gao et al. 2023; Davis et al. 2017). Similarly, in transportation systems, graph analysis proves instrumental in modeling transportation networks, facilitating the identification of bottlenecks and enabling critical improvements in route optimization, traffic management, and infrastructure planning to enhance overall efficiency (Leskovec et al. 2009). In academic research, the exponential growth of scholarly works presents challenges for researchers in locating relevant studies. To address this, Khalid et al. (2021a) introduced a two-stage real-time feedback query expansion technique that allows users to refine their search queries, leading to more precise and relevant retrievals. Furthermore, Khalid et al. (2021b) demonstrated that representing scholarly works within a citation network, augmented by classical information retrieval mechanisms and semantic-aware methods, can significantly enhance the retrieval and contextualization of academic literature. These advancements highlight the transformative potential of graph-based methodologies across diverse fields.
Anzeige
With the increasing availability of graph data, the need for effective graph analysis methods and tools has grown significantly. Over the years, different systems, tools and platforms have been proposed for network analysis and storage, with each system assessing its efficiency and usability with different datasets and metrics (Ammar and Özsu 2014). As such, it becomes difficult to compare the performance of the different systems.
This study explores and compares different graph analysis methods and tools to provide insights into their strengths, weaknesses, and applicability in different scenarios. We focus on several key graph analysis methods, including modularity, community detection, density, minimum spanning tree, clustering coefficient, betweenness centrality, eigenvector centrality, and strongly connected components. These methods provide researchers with significant insights into the structure and organization of graphs, allowing them to discover concealed patterns and structures inside intricate networks. We also compared the engagement metrics of each tool, including the number of downloads, forks, and stars. These metrics provide insights into the community’s interest, usage, and contribution to each tool. Analyzing these metrics is important because they offer a proxy for a tool’s popularity, user satisfaction, and active development. Understanding these aspects helps assess the libraries’ technical performance, support ecosystem, and reliability, which are crucial for researchers and practitioners when selecting the most appropriate tool for their projects.
We assess the computational speed of widely-used graph analysis tools such as NetworkX, EasyGraph, Rustworkx, Graph-tool, and Igraph on different network analyses to conduct our comparative research. These tools offer a variety of features for analyzing and visualizing graphs, enabling researchers to explore and analyze graph data rapidly. We aim to offer researchers and practitioners important insights into the strengths and limitations of different Python-based graph analysis tools by evaluating their performance using various methods and datasets. This work aims to guide in selecting suitable tools for specific graph analysis tasks, thereby improving our capacity to extract significant insights from intricate graph data. In this study, the terms network and graph will be used interchangeably. Our key contributions are summarized below:
This study provides a comprehensive performance comparison of several popular network analysis tools, specifically benchmarking their computational speed across various graph processing tasks.
We evaluated community engagement metrics such as the number of downloads, forks, and stars, providing insights into each tool’s reliability, popularity, and user satisfaction.
The findings assist practitioners, researchers, and developers in making informed decisions when selecting network analysis tools, enabling them to optimize resource use and project outcomes.
The rest of the paper is organized as follows: Sect. 2 discusses the literature in this domain. Section 3 describes the data used for benchmark evaluation. Section 4 discusses our research methodology. Section 5 provides our findings. We conclude our study with recommendations and limitations in Sect. 6.
2 Related works
This section presents previous works on benchmarking different systems, tools, and platforms for network analysis and storage. The review provided in this section is not meant to be exhaustive but to provide the readers with background knowledge on the work done in this paper.
Anzeige
Graphs or networks are data structures studied extensively in different fields. Hence, it is unsurprising that graph processing platforms’ efficiency and performance analytics have been studied extensively. One such work is Ammar and Özsu (2014), where the authors proposed the Waterloo Graph Benchmark (WGB) for meaningful comparison of graph systems to create a general platform for the global evaluation of graph processing systems.
Similarly, Armstrong et al. (2013) introduced a platform called Linkbench that provides a metric for evaluating the ability of production databases to handle the storage of social and web service data. Recognising the need for users to choose the most efficient solutions out of many possible solutions for graph data management systems, Grossniklaus et al. (2013) proposed a benchmark in terms of a data model, query workload, sample data sets, and usage scenarios. The authors provided performance results for these metrics using an open-source dataset. Lissandrini et al. (2018) expanded upon this work by introducing a micro benchmarking framework that included larger queries and operators on synthetic and real data from different areas.
Graphalytics, as proposed by Capotă et al. (2015), offers a complete set of tests specifically tailored to assess the efficiency of graph-processing platforms while dealing with extensive graph data. The standardized approach includes a broad collection of typical workloads, such as traversal, centrality, and community discovery techniques, to test the efficiency and scalability of various systems. This collection of research justifies generally evaluating graph processing and analytical tools and platforms, emphasizing the critical need for standardized benchmarks to facilitate meaningful comparisons across diverse systems.
Each reviewed study underscores the complexity and diversity of graph data applications, from social network analysis to semantic web ontologies. Building upon this foundation, we extend this work to benchmarking the computational speed of Python-based network tools. Extending this research to Python-based network analysis tools further enhances the breadth and depth of evaluative frameworks available to researchers and practitioners. Renowned for its versatility and extensive library support, Python offers robust solutions for network analysis tasks ranging from centrality and clustering analysis to community detection and visualization.
3 Data
This section describes the data used for benchmarking the network analysis tools. Four graph data types were used to benchmark the network tools in this research. The properties of the data are shown in Table 1. Facebook graph data (ego-facebook data) (Leskovec and Mcauley 2012) consisted of friends lists from Facebook collected from a survey using the Facebook app, forming an ego network. The dataset has been anonymized by replacing the IDs of each user with a new value. The graph data was created by connecting the ego networks using their shared friends. Google+ graph data (ego-google) (Leskovec and Mcauley 2012) consisted of circles of friends collected from users who shared their circles using the “share circle" feature on the app. Like the ego-facebook data, the ego-google graph data was created by connecting all the ego networks.
Bitcoin OTC trust weighted network (bitcoin) (Kumar et al. 2016) consisted of users who traded bitcoin using the Bitcoin OTC platform. A requirement of Bitcoin transactions is anonymity, so users on the platform are interested in the reputation of other users when dealing with them. The platform implemented a peer review system that allowed members to rate other members on a scale of \(-10\) to +10 (where a negative value indicates distrust and a positive value suggests trust). This research adjusted the scale to 0–20 as the Igraph requires positive weights. The multi-platform data (Akinnubi et al. 2024) consisted of topics, entities, and documents derived from contents extracted from Twitter, Reddit, YouTube, and blog posts. The graph consists of entity-document and topic-document relationships. The Pubmed Diabetes dataset (Namata et al. 2012) (pubmed) is a citation network consisting of scholarly articles from the PubMed database related to diabetes classified into one of three classes. The citation network consists of 44,338 edges.
The datasets used in this study were carefully chosen to cover a range of graph structures and instances and represent various network data. The purpose of these datasets is to offer a useful foundation for evaluating how well graph analysis tools perform in various contexts.
Table 1
Data matrix showing the properties of the graph data used in this research
Graph
Type
No. of nodes
No. of edges
Facebook (ego-facebook)
Undirected, unweighted
4039
88,234
Google-Plus (ego-google)
Directed, unweighted
107,614
13,673,453
Bitcoin OTC (bitcoin)
Directed, weighted
5881
35,592
Multi-platform
Undirected, unweighted
10,000
35,000
PubMed diabetes (pubmed)
Directed, unweighted
19,717
44,338
4 Method
This section describes the network analysis tools, network analysis and benchmarks used in this research. We used the average time taken for computation and platform statistics, such as popularity, maintenance, and documentation, as the major metrics for comparison. The remainder of the section is arranged as follows:
Section 4.1 discusses the Python-based network tools explored in this research.
Section 4.2 presents the network analysis methods used to benchmark the network tools.
Section 4.3 presents the tools and methods used in performance analysis of the network analysis tools.
Section 4.4 discusses the methods used for analyzing the platform statistics.
4.1 Network tools
Five network analysis tools were explored in this research: NetworkX, EasyGraph, Igraph, Rustworkx, and Graph-tool. These tools were chosen based on their widespread popularity and recognition, as they are officially listed on the Python Wiki1 as prominent libraries for graph analysis in Python. Table 2 presents the input and output formats supported by each tool, highlighting their compatibility with a diverse range of formats. A detailed description of each network analysis tool is provided later in this section.
Table 2
Comparison of Python-based network analysis tool based on common I/O functions
Tools
Network I/O types
EasyGraph
NetworkX
Igraph
Graph-tool
Rustworkx
Edge List
Yes
Yes
Yes
Yes
Yes
GraphML
Yes
Yes
Yes
Yes
Yes
GML
Yes
Yes
Yes
Yes
No
Adjacency
No
Yes
Yes
No
No
DOT
Yes
Yes
No
Yes
No
Graph visualization
Yes
Yes
Yes
Yes
Yes
GEXF
Yes
Yes
No
No
No
NetworkX is a Python package that is utilized for the creation, manipulation, and analysis of graphs. The software offers a range of tools for examining the organization and behaviour of networks. These capabilities include algorithms for creating graphs, calculating different network characteristics, and displaying networks visually (Hagberg et al. 2008). NetworkX facilitates the generation, interpretation, and alteration of networks. Although some methods in NetworkX can be accelerated by leveraging the NetworkX CUDA integration for supported GPU, only the CPU variants were considered in this research.
EasyGraph is an open-source Python library designed specifically for network analysis, offering a robust suite of tools for researchers and analysts to explore and analyze complex network structures. Notably, it features a C++ backend, which enhances computational performance and can be seamlessly accessed through its Python API (Gao et al. 2023). Furthermore, EasyGraph provides a range of functions for constructing graph-based machine learning models, including the Jump Hypergraph Convolution layer (Ji et al. 2020), Hypergraph Neural Network (Feng et al. 2019), General Hypergraph Neural Network (Gao et al. 2022), Hypergraph Networks with Hyperedge Neurons (Dong et al. 2020), HyperGraph Convolution Neural Network (Yadati et al. 2019), and UniGAT convolution layer (Huang and Yang 2021). In this research, we tested EasyGraph and its C++ enhancement through the provided Python interface denoted as EasyGraphCPP.
Rustworkx is a Python package designed to work with graphs and complex networks. It offers a range of functionalities that make it useful for various graph-related tasks (Treinish et al. 2022). Being written in Rust, the library leverages Rust’s capabilities for memory safety and concurrency, which can result in improved performance and more robust code.
Python-Igraph (Igraph) is a popular library for working with graphs in Python. It provides a wide range of features for creating, manipulating, analyzing, and visualizing graphs (Csardi and Nepusz 2006). The library is available for the Python, R and C programming languages.
Graph-tool is a Python library for manipulating and statistically analysing graphs (networks). It is built on top of the C++ library of the same name, which provides high performance and efficiency for handling large graphs (Tiago 2014). Graph-tool offers various features for working with graphs, including Graph Creation, Graph Manipulation, and Graph Algorithms.
4.2 Network analysis
This section briefly overviews the various network analysis methods utilized in this research. Table 3 summarizes these methods and indicates the tools that implement them. A detailed explanation of each method is provided below.
Table 3
Comparison of Python-based network analysis tool based on common network analysis methods
Tools
Network analysis
EasyGraph
NetworkX
Igraph
Graph-tool
Rustworkx
Community
Yes
Yes
Yes
No
No
Modularity
Yes
Yes
Yes
Yes
No
Average clustering coefficient
Yes
Yes
Yes
Yes
No
Strongly connected components
Yes
Yes
Yes
Yes
Yes
Biconnected component
Yes
Yes
Yes
Yes
Yes
Density
Yes
Yes
Yes
No
No
Eigenvector centrality
No
Yes
Yes
Yes
Yes
Betweenness centrality
Yes
Yes
Yes
No
Yes
Minimum spanning tree
Yes
Yes
Yes
Yes
Yes
4.2.1 Modularity and community detection
Comprehending the fundamental community structure is crucial for revealing concealed patterns, recognizing pivotal nodes, and acknowledging the network’s utility in the network’s vast and interconnected realm. Community detection algorithms play a crucial role in this endeavour as they aim to partition networks into significant groups or communities based on node relationships. Louvain algorithm introduced by Blondel et al. (2008) is one of the essential methods for detecting communities in large networks. The Louvain method is a sophisticated optimization algorithm that iteratively maximizes the modularity of network partitions using a multi-level approach. The quality of each partition is measured using modularity by comparing the total edges in a community to the anticipated size in a random network. Based on Newman (2010) modularity can be expressed using Eq. 1.
where m is the number of edges or sum of edges, A is the adjacency matrix of graph G, \(k_i\) is the degree of I, \(\gamma\) is the resolution parameter, and \(\delta (c_i c_j)\) is one if i and j are in the same community and 0 in all other cases.
The modularity algorithm and multi-level community detection algorithm (Blondel et al. 2008) are implemented in EasyGraph, NetworkX, and Igraph. Since the modularity functions require a partition as an input, the multilevel community partition is used as an input to the modularity function for each graph and network tool. Graph-tool implements Newman’s modularity (Newman 2006) and not the multilevel community detection and, as such, was not tested in this research since the community partition is required as an input.
4.2.2 Average clustering coefficient
The average clustering coefficient of a graph G is calculated as the mean of the local clustering coefficients of all nodes in the graph (Watts and Strogatz 1998). This metric indicates the graph’s nodes’ general propensity to group into communities or clusters. The average clustering coefficient is given by Eq. 2 (Newman 2003) where n is the number of nodes in the graph, and \(C_i\) is the local clustering coefficient for node i. A critical feature of many complex networks in the real world is their tendency to form tightly knit clusters, which may be inferred from the average clustering coefficient. Saramäki et al. (2007) presented a generalization to weighted networks. These generalizations provide a more sophisticated comprehension of clustering patterns in weighted networks, where link strength is important. Understanding the structure and operation of complex networks requires understanding their connectedness and how nodes are grouped based on the weights of the edges connecting them. Similarly, Barrat et al. (2004) introduced a different approach for calculating the average coefficient in a weighted graph implemented in Igraph. The average clustering coefficient is implemented for the undirected and directed graphs in NetworkX, EasyGraph, Graph-tool and Igraph.
A strongly connected component in a directed graph refers to a group of vertices where each vertex can be reached from every other vertex within the group (Tarjan 1972). Tarjan (1972) proposed a highly efficient approach for identifying strongly connected components (SCCs) in a directed graph. Tarjan’s technique utilizes depth-first search (DFS) and a stack-based methodology. The technique conducts a depth-first search (DFS) network traversal and keeps track of a stack of nodes that have been visited but have no strongly connected component (SCC). Nuutila and Soisalon-Soinen suggested a tweak to Tarjan’s algorithm to enhance efficiency, as documented in their publication (Nuutila and Soisalon-Soininen 1994). Nuutila and Soisalon-Soinen’s technique aims to find strongly connected components (SCCs) more straightforwardly without relying on the stack-based mechanism employed by Tarjan’s algorithm. The approach proposed by Nuutila and Soisalon-Soinen also employs a depth-first search (DFS) traversal of the network, but it circumvents the need for a stack to keep track of vertices. NetworkX uses the Tarjan algorithm with Nuutila modifications. All the tools considered in this research implement the SCC module for directed graphs only, except Igraph, which accepts both directed and undirected graphs.
4.2.4 Biconnected components
A biconnected component is a maximal subgraph in which at least two disjoint paths connect any two vertices. This means that if any single vertex is removed from a connected component, the component remains connected. Details about the method implemented in each tool need to be clarified, but NetworkX provides a reference to Tarjan (1972) for their algorithm optimization. The connected components module is implemented in all the tools explored in this research.
4.2.5 Density
The density of a graph is a measure of how many edges it has compared to the maximum possible number of edges it could have. The density for an undirected and directed graph are given in Eqs. 3 and 4 respectively (Hagberg et al. 2008)
$$\begin{aligned} d = \frac{2m}{n(n-1)} \end{aligned}$$
(3)
$$\begin{aligned} d = \frac{m}{n(n-1)} \end{aligned}$$
(4)
where m is the number of edges and n is the number of nodes. The density module is available in the NetworkX, EasyGraph, and Igraph libraries. Equation 4 represents the implementation of the density module in NetworkX. The implementation details of the density module are unclear from the Igraph and EasyGraph documentation.
4.2.6 Eigenvector centrality
Eigenvector centrality measures the influence of a node in a network (Zaki and Meira 2014). All nodes in the network are given relative scores based on the idea that a node’s score is influenced more by connections to high-scoring nodes than by the same connections to low-scoring nodes. When a node has a high eigenvector score, it indicates that it is linked to numerous other nodes that also have high scores (Newman 2008; Negre et al. 2018). Eigenvector centrality was first defined generally in networks based on social connections by Berge (1960) and was subsequently popularised by Bonacich (1972) as an essential measure in link analysis.
Generally, the eigenvector centrality x is given as the solution of
$$\begin{aligned} Ax = \lambda x \end{aligned}$$
Formally, it can be written as
$$\begin{aligned} x^T A = \lambda x^T \end{aligned}$$
(5)
where A is the adjacency matrix and \(\lambda\) is the largest eigenvalue. NetworkX, Igraph, and Rustworkx implement the eigenvector centrality module. The implementation in NetworkX is shown in the equation above. NetworkX implemented an additional module that uses SciPy sparse eigenvalue solver to find the eigenvector; however, only the native implementation was examined in this study. The eigenvector centrality module is implemented in Rustworkx based on Treinish et al. (2022).
4.2.7 Betweenness centrality
The betweenness centrality of a vertex v in a graph measures the extent to which the vertex lies on paths between other pairs of vertices (Watts and Strogatz 1998). Specifically, it is defined as the number of shortest paths between all pairs of vertices s and t that pass through v, divided by the total number of shortest paths between s and t in the graph (Freeman 1977). Formally, the betweenness centrality CB(v) of a node v is given by Eq. 6 (Brandes 2001).
The betweenness centrality module is available in NetworkX, Rustworkx, EasyGraph, Graph-tool, and Igraph. The module is implemented in Rustworkx based on the method described in Brandes (2001) and by Eq. 6. It is not clear how the module is implemented in the other tools. However, in NetworkX, a normalization procedure based on Borgatti and Halgin (2011) is implemented for stability.
4.2.8 Minimum spanning tree
A minimum spanning tree (MST) of a connected, undirected graph is a subgraph that is a tree (a connected acyclic graph) and that includes all the vertices of the original graph with the minimum possible total edge weight (Hagberg et al. 2008). In other words, an MST is a subset of the edges of the original graph that connects all the vertices with the minimum total edge weight. There are several algorithms for finding the MST of a graph, including Kruskal’s algorithm (Kruskal 1956) and Prim’s algorithm (Prim 1957). The main difference between the two algorithms lies in their approaches to selecting edges to include in the MST. Kruskal’s algorithm is greedy and builds the MST by repeatedly adding the shortest edge, which does not create a cycle in the MST. It starts with a forest of singleton trees (each node is its own tree) and repeatedly selects the shortest edge connecting two trees until all nodes are in a single tree. Kruskal’s algorithm sorts all the edges in the non-decreasing order of their weights and then processes them individually, adding an edge to the MST if it does not create a cycle. Prim’s algorithm is also a greedy algorithm that builds the MST by starting from an arbitrary node and repeatedly adding the shortest edge that connects a node in the MST to a node outside the MST. It starts with a single vertex and grows the MST by adding the shortest edge that connects a vertex in the MST to a vertex outside the MST until all vertices are in it. Prim’s algorithm maintains a priority queue of vertices outside the MST, where the priority of a vertex is the weight of the shortest edge connecting it to the MST.
Kruskal’s algorithm (Kruskal 1956) is implemented in Rustworkx and NetworkX. The choice of algorithm in Graph-tool depends on the user’s provision of the root node. Prim’s algorithm is used if the root is provided, while Kruskal’s is used if not. Prim’s algorithm is implemented in Igraph. In addition to Prim’s and Kruskal’s algorithms, NetworkX implements a third algorithm called the Boruvka algorithm (Nešetřil et al. 2001).
4.2.9 Average shortest path length
The average path length is a measure used in network analysis to determine the typical distance between nodes in a graph. It represents the average number of steps along the shortest paths for all possible pairs of network nodes. This metric provides insights into how efficiently information or influence can travel across the network (Newman 2010). Mathematically, if d(i, j) represents the shortest path distance between node i and j and n is the total number of nodes in the network, then the average shortest path length A is given by Eq. 7
The average shortest path length is available in NetworkX, Igraph, and EasyGraph. The method was tested for all datasets but failed for the ego-google dataset with NetworkX and EasyGraph (giving “error: Graph is not strongly connected").
4.2.10 Importance of selected methods in social network analysis
Social network analysis (SNA) plays a crucial role in understanding the structures, relationships, and behaviors that emerge within complex networks. To conduct such analysis effectively, modularity, clustering, centrality, and connectedness can be helpful in analyzing, interpreting, and predicting social phenomena.
For instance, identifying tightly knit groups using modularity allows researchers to reveal hidden interaction clusters when analysing social networks, such as online communities or professional relationships. These clusters can help uncover subcultures, interest groups, or collaborative teams, shedding light on how information flows within specific segments and how influence may be concentrated (Newman 2010; Akinnubi et al. 2024). Centrality measures like eigenvector and betweenness centrality are critical when identifying key players in a network. In organizational analysis, eigenvector centrality helps pinpoint individuals whose connections to other influential members, such as decision-makers or opinion leaders, amplify their importance (Howlader and Sudeep 2016). Betweenness centrality becomes invaluable in communication networks, where bridging nodes are often critical for controlling or disrupting information flow. For example, understanding the role of a single node in connecting disparate parts of a network can be instrumental in crisis communication or network defense (Kuzubaş et al. 2014).
In transportation or logistics networks, concepts like the minimum spanning tree and shortest path calculations are essential for optimization tasks (Shahin and Jaferi 2015). A transportation planner developing a cost-efficient route network may employ the minimum spanning tree to save construction expenses while maintaining connection. Also, the average shortest path length quantifies network efficiency-shorter paths signify enhanced accessibility, which is essential for urban planning and emergency response systems.
Biological and epidemiological networks benefit immensely from measures of clustering and connectivity. In the study of disease transmission, clustering coefficients highlight localized outbreaks and potential superspreader events (Molina and Stone 2012). Meanwhile, strongly connected components help epidemiologists model the robustness of a network’s transmission pathways, allowing them to identify the minimum interventions needed to break cycles of infection (Pastor-Satorras et al. 2015). Network density helps understand the intimacy of interactions in friendship networks or gauge connectivity in organizational structures, and density helps frame broader questions about the network’s purpose and function. For example, a sparse network might indicate inefficiencies or gaps in communication, while a highly dense network might suggest redundancy or resilience.
4.3 Benchmarking the network analysis tools
The version of each Network tool explored in this research is presented in Table 4. Pyperf (version 2.7.0) was used to write, run, and analyze the benchmarks. Pyperf is a tool designed to run benchmarks for Python programs in isolation from all other processes. This ensures stability and equal resources are available for all the benchmarks. It must be noted that despite the safety measures by the tools and the authors, there exists a possibility of change in resources available for each benchmark. This is beyond the control of the authors. The benchmark was carried out on a Linux system with 10 CPUs and 24GB RAM with Python 3.11 installed. Tables 5, 6, and 7 show the network analysis that was used to benchmark the network tools for each dataset. The methods tested are based on the availability of the module in the network tool. All methods are used with their default parameters.
Table 4
Network analysis tool and their corresponding version
Tool
Version
NetworkX
3.2.1
Rustworkx
0.14.1
Igraph
0.11.4
EasyGraph
1.1
Graph-tool
2.59
Table 5
Network analysis methods tested for the ego-facebook and multiplatform data
rustworkx
NetworkX
Igraph
EasyGraph
EasyGraphCPP
Graph-tool
Eigenvector centrality
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
X
\(\checkmark\)
Betweenness centrality
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
Community
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
Modularity
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
X
Density
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
Average clustering
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
\(\checkmark\)
Average shortest path length
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
Biconnected components
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
Minimum spanning tree
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
Effective size
X
X
X
\(\checkmark\)
\(\checkmark\)
X
Connected components
X
\(\checkmark\)
X
\(\checkmark\)
\(\checkmark\)
X
Table 6
Network analysis methods tested for the bitcoin data
rustworkx
NetworkX
Igraph
EasyGraph
EasyGraphCPP
Graph-tool
Eigenvector centrality
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
X
\(\checkmark\)
Betweenness centrality
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
Community
X
\(\checkmark\)
X
\(\checkmark\)
\(\checkmark\)
X
Modularity
X
\(\checkmark\)
X
\(\checkmark\)
X
X
Average clustering
X
X
\(\checkmark\)
\(\checkmark\)
X
\(\checkmark\)
Minimum spanning tree
X
\(\checkmark\)
\(\checkmark\)
X
\(\checkmark\)
\(\checkmark\)
Table 7
Network analysis methods tested for the ego-google and pubmed data
rustworkx
NetworkX
Igraph
EasyGraph
EasyGraphCPP
Graph-tool
Strongly connected components
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
Eigenvector centrality
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
X
\(\checkmark\)
Betweenness centrality
\(\checkmark\)
\(\checkmark\)
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
Community
X
\(\checkmark\)
X
\(\checkmark\)
\(\checkmark\)
X
Modularity
X
\(\checkmark\)
X
\(\checkmark\)
X
X
Density
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
Average clustering
X
\(\checkmark\)
\(\checkmark\)
\(\checkmark\)
X
\(\checkmark\)
Average shortest path length
X
X
\(\checkmark\)
X
X
X
4.4 Network tools engagement metrics
In addition to the performance metrics, each network tool is ranked based on library adoption and engagement metrics. These metrics are described below:
Number of downloads: This is extracted from Python Package Index (PyPI) and Anaconda (conda) repository-the two most popular sources for installing Python libraries (Halvorsen 2020; Kadiyala and Kumar 2017). We restrict these statistics to only the official sources for the installation of each tool. For example, if Anaconda is listed on the official website or repository as an installation source, we take only the number of downloads from Anaconda; if PyPi is listed as the installation source, we extract the statistics from PyPi. If both sources are listed, we sum the number of downloads per month from each source. This ensures a more accurate and objective representation of the data collected.
Github-based metrics: GitHub is a web-based platform that provides version control and collaboration capabilities for software development projects. It uses Git, a distributed version control system, to track changes in source code during software development. It is a popular resource for managing computer software, and it allows for collaboration where users can contribute to the development of open-source software by creating their own version of the software called a fork, making their changes and informing the software maintainers who accept or refuse their changes (Cosentino et al. 2016; Kalliamvakou et al. 2014). The number of forks for each network tool explored in this research from their official GitHub repository indicates the level of community involvement and contribution to a tool’s development. We also extract the number of stars each library has on GitHub. Stars are a vote of confidence in the library by users, indicating its popularity and usefulness.
Author rank: This is the rank given to each library based on the ease of installation, usage, and documentation. The author rank is a measure of a tool’s user-friendliness, ease of usage, and documentation quality. We rank the tools from 1 (best) to 5 (worst) based on the level of documentation and, by extension, ease of usage, choice of method names, and methods implemented.
5 Results and discussion
This section presents the performance test of each network tool on each network dataset explored in this research. The remainder of the section is described as follows:
Section 5.1 presents the result of the performance for each network tool.
Section 5.2 presents the engagement metrics for each tool.
5.1 Performance test results and analysis
Figure 1 shows the performance results of each network tool and method on the ego-facebook dataset. The results show a mixed outcome in the benchmark time.
The ego-fb graph is a classic example of a dense, undirected social network, where tools like igraph and Graph-tool excel due to their efficient low-level implementations. RustworkX demonstrates exceptional performance in calculating betweenness centrality, achieving a runtime of just 3.14 ms, significantly outperforming all other tools. This speed is indicative of RustworkX’s efficient traversal algorithms and optimized backend, making it particularly well-suited for tasks involving global measures of network structure. Additionally, RustworkX unlike other tools evaluated in this research implements the Betweenness centrality method described in Brandes (2001). In contrast, NetworkX struggles to handle this metric efficiently, requiring over 113 s for the same calculation, underscoring its limitations in processing dense networks. RustworkX performs comparably well, as it combines Python’s flexibility with Rust’s computational efficiency (Treinish et al. 2022), though it may lag slightly in operations like minimum spanning tree, and eigen-vector centrality where igraph and Graph-tool’s deeper optimizations dominate.
Graph-tool consistently excels across multiple tasks, including biconnected components and minimum spanning tree, where its use of parallelized computations and highly optimized C++ code gives it a distinct edge (Tiago 2014). This efficiency makes Graph-tool ideal for tasks requiring rapid decomposition of network structures. Igraph emerges as a standout performer in modularity-related computations. Its ability to compute modularity in just 401 nanoseconds reflects the sophistication of its matrix-based operations highly optimized C code (Csardi and Nepusz 2006), which are finely tuned for dense graph structures. Additionally, igraph’s performance on eigenvector centrality is commendable which closely rivals Graph-tool and outpaces RustworkX and NetworkX.
EasyGraphCPP exhibits robust performance in average shortest path length compared to NetworkX’s and EasyGraph. This result demonstrates the power of compiled code in accelerating operations that require traversing multiple paths across the graph. EasyGraph, while slower, maintains reasonable runtimes. NetworkX, while lagging significantly in speed for most metrics, remains a strong contender for tasks like biconnected components. However, its performance on more complex metrics like modularity and betweenness centrality illustrates the limitations of its Python-based implementation in handling computationally intensive tasks for larger, denser graphs. This can be attributed to its reliance on pure Python and object-oriented data structures that prioritize usability over speed (Hagberg et al. 2008).
Figure 2 depicts the performance of each network analysis tool on the ego-google dataset. The directed nature of this graph introduces computational challenges, particularly in algorithms like strongly connected components and betweenness centrality. EasyGraph exhibits exceptional computational speed in community detection and strongly connected components analysis, indicating highly optimized algorithms for these operations. This remarkable efficiency likely stems from highly optimized algorithms and the effective utilization of data structures that minimize computational overhead. EasyGraphCPP, being implemented in C++, benefits from the performance advantages of a compiled language, allowing for lower-level memory management and faster execution compared to interpreted languages. Similarly, NetworkX exhibits great speed in computing the strongly connected components. In contrast, NetworkX exhibits significantly longer computation times for community detection and betweenness centrality.
Igraph presents an interesting performance profile, with relatively efficient computation times for average clustering and betweenness centrality compared to NetworkX. Its strongly connected components’ computation time is in the milliseconds range, which, while slower than EasyGraph, indicates a level of optimization suitable for large networks. Igraph’s core is written in C, providing a balance between performance and ease of use through its high-level interfaces. This design choice allows igraph to handle complex computations more efficiently than tools relying solely on higher-level languages.
The performance of GraphTools and Rustworkx falls between the extremes observed with EasyGraph and NetworkX. Their moderate computation times suggest that they employ optimized algorithms and benefit from the performance characteristics of their implementation languages-GraphTools possibly leveraging efficient C++ code and Rustworkx utilizing Rust’s performance and safety features. Rust, in particular, offers memory safety without garbage collection and allows for high-performance computations, which may explain Rustworkx’s competitive times for eigenvector centrality and betweenness centrality.
The choice of algorithms implemented for each metric is a key factor influencing these results. Metrics like betweenness centrality are inherently computationally intensive because they require the calculation of shortest paths between all pairs of nodes. Tools that achieve faster computation times for such metrics may employ algorithmic optimizations like approximation algorithms, parallel processing, or more efficient data structures. For example, Rustworkx’s lower betweenness centrality computation time suggests using such optimizations, which can drastically reduce the time complexity in practical scenarios.
The performance results for the network analysis tools on the Bitcoin OTC data are shown in Fig. 3.
Starting with EasyGraph, the tool demonstrates remarkable speed in computing community detection. Such rapid performance suggests highly optimized algorithms, likely leveraging efficient data structures tailored for handling weighted and directed graphs. However, when it comes to more computationally intensive metrics like modularity and average clustering, EasyGraph records computation times of approximately 3.17 and 3.04 s, respectively. These times are reasonable given the complexity of these metrics in weighted and directed contexts, where the calculations must account for both the direction and weight of edges, adding layers of computational overhead.
Betweenness centrality, a metric known for its computational intensity due to the necessity of calculating shortest paths between all pairs of nodes, takes 227 s on EasyGraph. This substantial time reflects the algorithmic complexity and possibly the limitations of the programming language used-Python in this case-which, being interpreted, can introduce performance bottlenecks in heavy computations.
Turning to EasyGraphCPP, the C++ counterpart of EasyGraph, we observe a significant improvement in performance for betweenness centrality. This dramatic reduction underscores the efficiency gains achieved through compiled languages like C++. C++ allows for lower-level memory management and faster execution, particularly for intensive calculations inherent in metrics like betweenness centrality. The community detection time remains impressively low, indicating that EasyGraphCPP retains the algorithmic optimizations of EasyGraph while capitalizing on the performance advantages of C++.
NetworkX, a widely used Python library, exhibits longer computation times across the board. Community detection takes 830 milliseconds, which, while acceptable, is significantly slower than the nanosecond times of EasyGraph and EasyGraphCPP. These times suggest that NetworkX, being pure Python, may not be as efficient for large-scale or computationally heavy tasks due to the overhead associated with Python’s interpreted nature and higher-level abstractions. Betweenness centrality computation in NetworkX is comparable to EasyGraph’s performance for the same metric. This reinforces the notion that Python-based tools may struggle with the computational demands of such metrics, especially in weighted and directed graphs where the complexity is amplified.
GraphTools presents impressive efficiency, particularly in computing eigenvector centrality and betweenness centrality. Eigenvector centrality is computed in 9.81 ms and betweenness centrality in 1.41 s, making it one of the fastest tools for these metrics. The swift computation times suggest that GraphTools employs advanced algorithmic strategies, including parallel processing or optimized mathematical routines that reduce computational complexity. Additionally, its minimum spanning tree and average clustering computations are completed in milliseconds, further highlighting its efficiency.
Similarly, igraph demonstrates strong performance, with eigenvector centrality computed in 20.3 ms and betweenness centrality in 9.48 s. While slower than GraphTools for betweenness centrality, igraph still outperforms the Networkx and EasyGraph significantly. Igraph’s core implementation in C contributes to its efficiency, allowing it to handle computationally demanding tasks more effectively. A noteworthy constraint of the Igraph for the network analysis methods employed in this study is its inability to handle signed weights within the network.
Rustworkx, utilizing the Rust programming language known for its performance and safety, computes eigenvector centrality in 7.10 ms—the fastest among the tools evaluated for this metric. Rust’s modern language features, combined with its focus on zero-cost abstractions and efficient memory management, enable Rustworkx to achieve high performance, particularly for algorithms that can benefit from concurrent execution.
As demonstrated in Fig. 4, the execution of both Graph-tool and Igraph on the multi-platform data mirrored the results observed with the ego-facebook dataset, showcasing their overall superiority for this type of analysis. Finally, the evaluation results for pub-med data are presented in Fig. 5. Similar to the EasyGrapph and EasyGraphCPP performance on the ego-google dataset, both tools demonstrate outstanding efficiency in community detection. Similarly, EasyGraph and Networkx had impressive performances in extracting the strongly connected components. These consistent results in the two directed graphs (ego-google and pubmed) indicate the algorithms implemented in these tools are well-optimized for these purposes. GraphTool had an impressive performance on betweenness centrality over Rustworkx, while Rustworkx demonstrates strong performance in eigenvector centrality computation.
Several factors contribute to the performance recorded for each tool on the different analysis. The structure and size of the networks analyzed play a significant role. Dense networks with high connectivity can increase computation times due to the more substantial number of edges to process. Tools optimized for sparse matrices or that use adjacency lists efficiently can outperform others when dealing with such networks. If a tool is specifically optimized for the types of networks commonly studied in social network analysis-often large and sparse-they would naturally exhibit superior performance.
Moreover, language-level optimizations contribute to these differences. Compiled languages like C++ and Rust allow developers to write code closer to the hardware, enabling fine-tuned optimizations and better use of system resources. They can exploit multi-threading and parallelism more effectively, which is crucial for handling large-scale computations. Interpreted languages like Python, used by NetworkX, introduce an additional layer between the code and the machine, potentially slowing down execution despite their ease of programming and rich ecosystems.
Another aspect to consider is the overhead associated with high-level language features and garbage collection, which can unpredictably impact performance. Tools like igraph mitigate this by providing a high-level interface while maintaining a core written in a compiled language, offering a compromise between speed and usability.
These performance differences have practical implications in the context of social network analysis. Rapid computation of metrics like community detection and centrality measures is essential when working with massive social networks, such as those derived from online platforms or communication networks. The ability to process data quickly allows for more iterative and exploratory analyses, leading to deeper insights and more timely conclusions.
To provide a better understanding of the behavior of these tools with different graph sizes, we evaluated the minimum spanning tree (a standard analytical method implemented by all the tools) algorithm from each tool on the Megascale cell-cell similarity network (Zitnik et al. 2018; Zheng et al. 2017) at different node sizes. The result is shown in Fig. 6. RustworkX, GraphTool, and Igraph demonstrate better scalability as the number of nodes increases. Their curves rise more slowly, indicating that their computation times grow slower than others. NetworkX shows the steepest curve, suggesting that its computation time increases rapidly with graph size. This highlights its limited efficiency in handling larger graphs.
Fig. 1
Performance test result for each network analysis tool on the ego-facebook data for method identified in Table 5. Tools with methods not implemented or not tested due to errors are not represented in the chart
Fig. 2
Performance test result for each network analysis tool on the ego-google data for method identified in Table 7. Tools with methods not implemented or not tested due to errors are not represented in the chart
Fig. 3
Performance test result for each network analysis tool on the bitcoin data for method identified in Table 6. Tools with methods not implemented with weights or not tested due to errors are not represented in the chart
Fig. 4
Performance test result for each network analysis tool on the multiplatform data for method identified in Table 5. Tools with methods not implemented or not tested due to errors are not represented in the chart
Fig. 5
Performance test result for each network analysis tool on the pubmed data for method identified in Table 7. Tools with methods not implemented or not tested due to errors are not represented in the chart
Fig. 6
Performance test result for each network analysis tool on the Megascale cell-cell similarity network dataset at different node sizes. The EasyGraph plot is directly behind the EasyGraphCPP plot
×
×
×
×
×
×
5.2 Network tool statistics and analysis
Table 8 shows the engagement metrics for each network tool explored in this research. NetworkX and Igraph offer installation options through both PyPI and Conda package managers, providing flexibility for users. EasyGraph and Rustworkx, on the other hand, primarily utilize pip for installation. Graph-tool prioritizes Conda as its primary installation method. NetworkX exhibits strong community engagement, evidenced by its leading position in downloads, forks, and stars on platforms like GitHub. While its longevity-existing since 2008 (Hagberg et al. 2008) contributes-a comparison with Igraph, a similarly established library, suggests NetworkX’s popularity transcends mere age. This can likely be attributed to its user-friendly API, comprehensive documentation, and active community support. These factors are further corroborated by the author’s rank for NetworkX, with Graph-tool emerging as a close competitor in terms of user-friendliness and documentation.
EasyGraph can be regarded as a peer to NetworkX regarding the methods implemented. However, the documentation is heavily lacking compared to the other libraries explored in this research. Figure 7 shows the download trends of all the network tools explored in this research. The figure shows that NetworkX has been dominating the scene since its inception. Its popularity has continued to increase and dwarfs other tools. Despite its relatively newer entrance into the scene, EasyGraph has grown popular among users and competes actively with the veteran Graph-tool. Rustworkx and Igraph are also popular among users.
While NetworkX enjoys significant popularity based on community engagement metrics, it exhibited slower performance in most benchmarks. Conversely, Graph-tool and Igraph, despite their lower popularity, demonstrate superior speed and efficiency. The underlying reasons for NetworkX’s sustained popularity still need to be determined. Potential factors, such as well-documented methods and a user-friendly API, warrant further investigation. The results and analysis in this research suggest a trade-off between user-friendliness and performance when choosing network analysis tools. The optimal choice depends on project-specific requirements, prioritizing speed and efficiency for computationally intensive tasks or ease of use for exploratory analyses.
Table 8
Engagement metrics for network tools explored in this research
Number of downloads
Number of forks
Number of stars
Author rank
NetworkX
1,206,494,278
3170
14,404
1
EasyGraph
443,269
31
355
5
Rustworkx
13,692,089
140
951
4
Igraph
22,191,560
247
1263
3
Graph-tool
390,947
_
23 1
2
The information was extracted from the project gitlab page
Fig. 7
Number of downloads of each network tool extracted from listed official sources. Extracted (06/23/2024)
×
6 Conclusion and limitations
This study benchmarked various network analysis tools (i.e. NetworkX, RustworkX, Igraph, EasyGraph, and Graph-tool) by evaluating engagement metrics like downloads, stars, and forks alongside their performance on the following network analysis methods: bi-connected components, modularity, community, connected component, average clustering coefficient, effective size, density, average shortest path length, minimum spanning tree, and eigenvector and betweenness centrality.
Our findings reveal that Igraph and Graph-tool emerge as the most versatile and efficient tools across all the datasets. Igraph excels in calculating metrics like modularity, density, and average shortest path length. EasyGraph, on the other hand, demonstrates strength in community detection and finding connected components, making it a good choice for tasks focused on these metrics. NetworkX, while showing promise in extracting bi-connected components for undirected graphs, needs to catch up in other areas. Some notable observations about the tested tools are listed below:
Igraph uniquely implements strongly connected components for undirected graphs, even though strongly connected components are inherently defined for directed graphs. The methodology employed by Igraph for this adaptation remains unclear, raising questions about its alignment with theoretical definitions.
While Igraph supports weighted social network analysis methods, it does not accommodate negative weights, effectively excluding signed graphs from its functionality. This limitation restricts its applicability to certain real-world networks where signed edges are essential.
NetworkX efficiently extracts biconnected components for undirected graphs (e.g., ego-facebook and multiplatform datasets) and strongly connected components for directed graphs (e.g., ego-google datasets). These capabilities highlight NetworkX’s strength in component extraction tasks.
EasyGraph stands out by offering a robust and efficient implementation of the effective size method for both undirected and directed graphs. This capability is particularly valuable for analyzing large datasets, as other libraries’ effective size methods are computationally intensive.
Both Igraph and Graph-tool consistently exhibit reliable performance across various metrics, making them dependable choices for computationally intensive network analysis tasks.
RustworkX is particularly impressive at calculating the betweenness centrality of a graph.
Igraph is the only tool capable of successfully computing the average shortest path length on a weighted, directed graph (e.g., Bitcoin transactions). NetworkX and EasyGraph encountered limitations: NetworkX reported errors due to graph disconnection, while EasyGraph, though functional for unweighted data, indicated that its Dijkstra-based implementation for weighted graphs is not yet supported. These challenges underscore Igraph’s leadership in handling such tasks effectively.
While computational performance is a significant factor in selecting a network analysis tool, it is not the only consideration. The choice also depends on the availability of specific algorithms, ease of integration with existing data processing pipelines, community support, and the learning curve associated with each tool. For instance, although igraph offers superior performance, researchers might prefer NetworkX for its extensive documentation and the vast array of algorithms it provides, despite its slower execution times.
This research offers a clear, comparative analysis of popular network analysis tools based on their computational performance and community engagement metrics. By highlighting which tools are faster and more efficient, the study empowers practitioners, researchers, and developers to make informed decisions tailored to their needs. Understanding that a tool’s popularity does not necessarily correlate with its performance allows users to avoid defaulting to the most common options. Instead, they can select tools that optimize efficiency for large datasets or computationally intensive tasks, leading to significant savings in computational resources and time-crucial factors for large-scale or time-sensitive projects.
In this research, we focused solely on Python-based network analysis tools. Expanding the scope to include libraries from other programming languages (e.g., R) would provide a more comprehensive picture of the network analysis landscape. Analyzing the adoption rate of these tools across various industries could also offer valuable insights into their real-world use cases and popularity drivers. We evaluate the performance of graph analysis tools using specific datasets. While these datasets were carefully chosen to represent a variety of graph structures and sizes, they may not fully capture the diversity and complexity of real-world social network analysis (SNA) applications. Social network datasets vary widely in terms of scale, density, topology, and application context, and it is impractical to test all possible variations. Future studies could expand this work by incorporating a broader range of datasets to ensure more comprehensive benchmarking across different SNA scenarios.
Acknowledgements
This research is funded in part by the U.S. National Science Foundation (OIA-1946391, OIA-1920920, IIS-1636933, ACI-1429160, and IIS-1110868), U.S. Office of the Under Secretary of Defense for Research and Engineering (FA9550-22-1-0332), U.S. Army Research Office (W911NF-20-1-0262, W911NF-16-1-0189, W911NF-23-1-0011, W911NF-24-1-0078), U.S. Office of Naval Research (N00014-10-1-0091, N00014-14-1-0489, N00014-15-P-1187, N00014-16-1-2016, N00014-16-1-2412, N00014-17-1-2675, N00014-17-1-2605, N68335-19-C-0359, N00014-19-1-2336, N68335-20-C-0540, N00014-21-1-2121, N00014-21-1-2765, N00014-22-1-2318), U.S. Air Force Research Laboratory, U.S. Defense Advanced Research Projects Agency (W31P4Q-17-C-0059), Arkansas Research Alliance, the Jerry L. Maulden/Entergy Endowment at the University of Arkansas at Little Rock, and the Australian Department of Defense Strategic Policy Grants Program (SPGP) (Award Number: 2020-106-094). Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the funding organizations. The researchers gratefully acknowledge the support.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.