This is a package that helps you convert an array of edges to a directed or undirected graph(adjacency list)
prints a dependency graph in dot format for your typescript or react project
Base for creating objects that behave like a Property Graph.
A graph data structure with topological sort.
Polygonizes a set of lines that represents edges in a planar graph.
TypeScript definitions for toposort
An edge program that renders edges as curves for sigma.js
React Flow - A highly customizable React library for building node-based editors and interactive flow charts.
Topological indexing for simplicial complexes
xyflow core system that powers React Flow and Svelte Flow.
Svelte Flow - A highly customizable Svelte library for building node-based editors, workflow systems, diagrams and more.
A highly customizable React library for building node-based editors and interactive flow charts
Louvain community detection for graphology.
Finds all elementary circuits of a directed graph using Johnson's algorithm (1975)
Graphviz DOT rendering and animated transitions for D3
graph data structure
A react component to render nice graphs using vis.js
Convert a planar graph to a collection of nest polylines
Topological sort of directed ascyclic graphs (like dependecy lists)
Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis
Simplifies a planar graph
A JavaScript library aimed at visualizing graphs of thousands of nodes and edges.
📈 Beautiful, high-performance Graphs and Charts for React Native
Simple dependency graph.
Allows rails models to work as the edges and nodes of a directed acyclic graph (dag). The edges may be typed.
This gem can make Nodes and Edges data that are in txt transforming ruby objects.
Rgraphum: Graphum ruby implementation
lazy_high_charts is leading edge rubyist render charts gem for displaying Highcharts graphs.
A simple weighted graph implementation that stores edges in an adjacency list.
Networkr is a Ruby gem inspired by the Python package NetworkX. It includes basic functionality for the creation, manipulation, and analysis of graphs. Graphs supported include undirected single-edge graphs (weighted or unweighted), directed single-edge graphs (weighted or unweighted), and undirected multi-edge graphs (weighted or unweighted). Algorithms available include Dijkstra's shortest paths, Karger's minimum cut, Kosaraju's strongly connected components, and Prim's minimum spanning tree.
llm-graph is a Ruby gem that provides verioned llm conversation graphs. It supports both directed and undirected graphs, and includes methods for adding and removing nodes and edges, checking for the existence of nodes and edges, and other common graph operations.
Implements Dijkstra's algorithm to find the shortest path in a graph. The cost of an edge can be more general than just a numeric value.
Native implementation of Dijkstra algorithm for finding the shortest path between two vertices in a large, sparse graphs. Underlying algorithm is implemented in C using a priority queue. Edges are represented using linked lists rather than an adjacency matrix to reduce memory footprint when operating on very large graphs where the average number of edges between nodes is relatively small (e.g. < 1/10 the number of nodes). See https://en.wikipedia.org/wiki/Dijkstra's_algorithm for additional information.
In computer science, a disjoint-set data structure, also called a union–find data structure or merge–find set, is a data structure that keeps track of a set of elements partitioned into a number of disjoint (non-overlapping) subsets. It provides near-constant-time operations (bounded by the inverse Ackermann function) to add new sets, to merge existing sets, and to determine whether elements are in the same set. In addition to many other uses (see the Applications section), disjoint-sets play a key role in Kruskal's algorithm for finding the minimum spanning tree of a graph. A disjoint-set forest consists of a number of elements each of which stores an id, a parent pointer, and, in efficient algorithms, a value called the "rank". The parent pointers of elements are arranged to form one or more trees, each representing a set. If an element's parent pointer points to no other element, then the element is the root of a tree and is the representative member of its set. A set may consist of only a single element. However, if the element has a parent, the element is part of whatever set is identified by following the chain of parents upwards until a representative element (one without a parent) is reached at the root of the tree. Forests can be represented compactly in memory as arrays in which parents are indicated by their array index. Disjoint-set data structures model the partitioning of a set, for example to keep track of the connected components of an undirected graph. This model can then be used to determine whether two vertices belong to the same component, or whether adding an edge between them would result in a cycle. The Union–Find algorithm is used in high-performance implementations of unification. This data structure is used by the Boost Graph Library to implement its Incremental Connected Components functionality. It is also a key component in implementing Kruskal's algorithm to find the minimum spanning tree of a graph. Note that the implementation as disjoint-set forests doesn't allow the deletion of edges, even without path compression or the rank heuristic. Sharir and Agarwal report connections between the worst-case behavior of disjoint-sets and the length of Davenport–Schinzel sequences, a combinatorial structure from computational geometry.