A version of the graph algorithms described in:
Structuring Depth-First Search Algorithms in Haskell, by David King and John Launchbury.
Static and Dynamic Inductive Graphs
Adjacency list representation of a graph, mapping each vertex to its list of successors.
Simple graphviz output.
Graph generator library and standalone graph generator. The generator allows you to generate your data once and then use it for benchmarking and debugging. Graph generation algorithm follows Graph500 specification http://www.graph500.org/specifications#sec-3_3.
A library to use graph theory to analyse the relationships inherent in discrete data.
Tarjan's algorithm for computing the strongly connected components of a graph.
This library provides a monadic EDSL to define your own port graph rewrite system in Haskell. Once you have specified the signature of your nodes and a set of rewrite rules, you can apply these rules on a graph to effect a graph transformation. The aim of this library is to make it as convenient as possible to define such a system and experiment with it and is not intended as a backend for high-performance computation.
Currently the following combinators are supported: S K I B C S B C' W
Once a graph rewriting system has been specified using the graph-rewriting library this package can be used to create an application that allows to experiment with this system by interactively applying the rewrite rules. The usage of the interface is the same for all applications. In the center you will see the graph. It might be moving around which is due the force-directed layouting. On the top-left corner you will find a menu with the individual rewriting rules of the rewriting system. The controls are described in the GraphRewriting.GL.UI module.
Lambdascope is an optimal implementation of the »²-calculus described in the paper "Lambdascope - Another optimal implementation of the lambda-calculus" by Vincent van Oostrom, Kees-Jan van de Looij, and Marijn Zwitserlood. Call "lambdascope" with one of the files from the "examples" directory as an argument. For usage of the GUI see GraphRewriting.GL.UI. Use the "--lmo" flag for leftmost outermost evalution and "--bench" for non-graphical evaluation to weak head normal form.
Defines basic methods for force-directed node displacement that can be combined into an incremental graph-drawing procedure. See graph-rewriting-ski package for an example.
This package serves as an example for how to use the graph-rewriting, graph-rewriting-layout, and graph-rewriting-gl packages to create a graph rewriting system with an interactive, graphical front-end. The SKI combinator calculus is implemented once as an interaction net with combinators that accumulate their arguments, and once in a more direct manner. The sources (of the interaction net implementation) are well documented and serve as a tutorial for implementing your own rewrite system. Start reading in INet/Graph.hs. To run the program run either the "ski-inet" or the "ski-direct" with one of the files from the "examples" directory as an argument. For usage of the GUI see GraphRewriting.GL.UI.
Defines a mechanism to add evaluation strategies to graph rewriting systems. Currently only leftmost-outermost reduction is implemented.
Given a set of term rewriting rules and an initial term with this tool you can interactively evaluate the corresponding term graph. The employed rule set has to be defined in one or more files. In the examples-directory a few rewriting systems are already supplied. To see how it works invoke the with the SKI-combinator rules and an initial term as arguments: trs examples/ski.trs "SK(S(KIS)K)I". On how to interact with the application see the GraphRewriting.GL.UI module of the graph-rewriting-gl package.
Evaluate a »-letrec term in an interactive graph reduction system. It uses duplicators to explicitly render fully-lazy sharing according to Wadsworth's approach.
Serialization of data structures with references.
Simple Wrapper for generating Graph provided by Data.Graph.Inductive. It also contains PageRank calculator.
Walk over a graph, abstracting away from the underlying representation, not caring about precise order
A declarative, monadic graph construction language for small graphs. See README.
Build a graph from a list of nodes uniquely identified by keys, with a list of keys of nodes this node should have edges to. The out-list may contain keys that don't correspond to nodes of the graph; they are ignored.
Identical to graphFromEdges, except that the return value does not include the function which maps keys to vertices. This version of graphFromEdges is for backwards compatibility.
This module is a functional wrapper around OpenGL, so you don't have to go into the deep, dark world of imperative stateful programming just to draw stuff. It supports 2D only (for now), with support drawing geometry, images, and text.
Should be able to load anything that Google SketchUp produces -- other than that, all bets are off.
Classes for renderable objects.
This library provides interfaces for creating easily graphical UIs especially for computer vision purposes, and for rendering information in graphical form. Implementations are provided for CV libraries. Example applications are included. (This is an early preview version)
This package contains a program that computes "dot" graphs from the dependencies of a number of Haskell modules.
Show more results