graph

Graph is a Perl module with graph data structures and algorithms.

SYNOPSIS

use Graph;
my $g0 = Graph->new; # A directed graph.

use Graph::Directed;
my $g1 = Graph::Directed->new; # A directed graph.

use Graph::Undirected;
my $g2 = Graph::Undirected->new; # An undirected graph.

$g->add_edge(...);
$g->has_edge(...)
$g->delete_edge(...);

$g->add_vertex(...);
$g->has_vertex(...);
$g->delete_vertex(...);

$g->vertices(...)
$g->edges(...)

Graph++ is a simple, yet powerful graphing application that allows users to effortlessly evaluate equations and mathematical functions graphically. Using some of Z Systems modular technology, Graph++ incorporates many of the features included within LiveWires graphs. Features that allow data to be copied and pasted into various applications, graphs that can be exported as image files, or graphs which can be copied and pasted as images directly into numerous applications. Graph++ even provides users with the capabilities to evaluate equations producing data sets with more than half a million (500,000 +) elements. This application is perfect for anyone.

Digi Graph is digital graph paper, that enables to draw on graph paper on screen, and save and print your drawings.

raph paper is very handy to have. As a game designer, I use a lot of graph paper for creating maps, sketching objects, etc.

Digi Graph is an application I created for my own personal use but I have released it for everyone to use. Basically, Digi Graph is digital graph paper.

GD::Graph is a graph plotting module for Perl 5.

SYNOPSIS

use GD::Graph::moduleName;

GD::Graph is a perl5 module to create charts using the GD module. The following classes for graphs with axes are defined:

GD::Graph::lines

Create a line chart.

GD::Graph::bars and GD::Graph::hbars

Create a bar chart with vertical or horizontal bars.

GD::Graph::points

Create an chart, displaying the data as points.

GD::Graph::linespoints

Combination of lines and points.

GD::Graph::area

Create a graph, representing the data as areas under a line.

GD::Graph::mixed

Create a mixed type graph, any combination of the above. At the moment this is fairly limited. Some of the options that can be used with some of the individual graph types wont work very well. Bar graphs drawn after lines or points graphs may obscure the earlier data, and specifying bar_width will not produce the results you probably expected.

Additional types:

GD::Graph::pie

Create a pie chart.

USAGE:

Fill an array of arrays with the x values and the values of the data sets. Make sure that every array is the same size, otherwise GD::Graph will complain and refuse to compile the graph.

@data = (
["1st","2nd","3rd","4th","5th","6th","7th", "8th", "9th"],
[ 1, 2, 5, 6, 3, 1.5, 1, 3, 4],
[ sort { $a <=> $b } (1, 2, 5, 6, 3, 1.5, 1, 3, 4) ]
);

If you dont have a value for a point in a certain dataset, you can use undef, and the point will be skipped.

Create a new GD::Graph object by calling the new method on the graph type you want to create (chart is bars, hbars, lines, points, linespoints, mixed or pie).
my $graph = GD::Graph::chart->new(400, 300);

Set the graph options.

$graph->set(
x_label => X Label,
y_label => Y label,
title => Some simple graph,
y_max_value => 8,
y_tick_number => 8,
y_label_skip => 2
) or die $graph->error;
and plot the graph.
my $gd = $graph->plot(@data) or die $graph->error;

Then do whatever your current version of GD allows you to do to save the file. For versions of GD older than 1.19 (or more recent than 2.15), youd do something like:

open(IMG, >file.gif) or die $!;
binmode IMG;
print IMG $gd->gif;
close IMG;
and for newer versions (1.20 and up) youd write
open(IMG, >file.png) or die $!;
binmode IMG;
print IMG $gd->png;
or
open(IMG, >file.gd2) or die $!;
binmode IMG;
print IMG $gd->gd2;

Then theres also of course the possibility of using a shorter version (for each of the export functions that GD supports):

print IMG $graph->plot(@data)->gif;
print IMG $graph->plot(@data)->png;
print IMG $graph->plot(@data)->gd;
print IMG $graph->plot(@data)->gd2;

If you want to write something that doesnt require your code to know whether to use gif or png, you could do something like:

if ($gd->can(png)) { # blabla }

or you can use the convenience method export_format:

my $format = $graph->export_format;
open(IMG, ">file.$format") or die $!;
binmode IMG;
print IMG $graph->plot(@data)->$format();
close IMG;

or for CGI programs:
use CGI qw(:standard);
#...
my $format = $graph->export_format;
print header("image/$format");
binmode STDOUT;
print $graph->plot(@data)->$format();

(the parentheses after $format are necessary, to help the compiler decide that you mean a method name there)

SVG::Graph is a Perl module to visualize your data in Scalable Vector Graphics (SVG) format.

SYNOPSIS

use SVG::Graph;
use SVG::Graph::Data;
use SVG::Graph::Data::Datum;

#create a new SVG document to plot in...
my $graph = SVG::Graph->new(width=>600,height=>600,margin=>30);

#and create a frame to hold the data/glyphs
my $frame = $graph->add_frame;

#lets plot y = x^2
my @data = map {SVG::Graph::Data::Datum->new(x=>$_,y=>$_^2)}
(1,2,3,4,5);
my $data = SVG::Graph::Data->new(data => @data);

#put the xy data into the frame
$frame->add_data($data);

#add some glyphs to apply to the data in the frame
$frame->add_glyph(axis, #add an axis glyph
x_absolute_ticks => 1, #with ticks every one
#unit on the x axis
y_absolute_ticks => 1, #and ticks every one
#unit on the y axis

stroke => black, #draw the axis black
stroke-width => 2, #and 2px thick
);

$frame->add_glyph(scatter, #add a scatterplot glyph
stroke => red, #the dots will be outlined
#in red,
fill => red, #filled red,
fill-opacity => 0.5, #and 50% opaque
);

#print the graphic
print $graph->draw;

SVG::Graph is a suite of perl modules for plotting data. SVG::Graph currently supports plots of one-, two- and three-dimensional data, as well as N-ary rooted trees. Data may be represented as:

Glyph Name Dimensionality supported
1d 2d 3d tree
--------------------------------------------------------
Axis x
Bar Graph x
Bubble Plot x
Heatmap Graph x
Line Graph x
Pie Graph x
Scatter Plot x
Spline Graph x
Tree x

SVG::Graph 0.01 is a pre-alpha release. Keep in mind that many of the glyphs are not very robust.

Insta Graph description
Graph cell values automatically and instantly by selecting a range in Excel. Insta-Graph is an add-in for Microsoft Excel that will revolutionize the way you create and use graphs (aka charts) in Excel. Anyone who has to analyze information, identify trends, prepare budgets, forecasts, or look at any other information in Excel where graphing is helpful will benefit from Insta-Graph.

Insta-Graph overcomes major weaknesses of the built in charting tool that ships with Excel. You can graph cell values automatically and instantly simply by selecting a range in Excel. As you select, unselect, or change cells the graph changes instantly to reflect your selection. You can predefine an unlimited number of formats and layouts for your graphs and save them as themes in Insta-Graph.

At every application startup the previous used theme will be applied. Insta-Graph offers a more organized layout of the available graph options. You can add the graph into your Excel workbook. Insta-Graph has numerous other features built in that improve on Excel charting.

Here are some key features of "Insta Graph":

· As your selection changes the graph updates instantly
· Pick rows or columns that will always be graphed along with the cells you are selecting
· Have more than one graph open at the same time
· Each instance of Insta-graph is opened in a seperate window which can float above your work or even on a second monitor
· As you scroll to new locations in Excel the graph is always visible and accessible because it is not part of the worksheet
· Save your graphs and charts as images instantly with a click of a button
· Print your graphs and charts instantly with a click of a button
· Send the graphs back to Excel so that it becomes an Excel chart
· Maximize your graph to full screen when graphing a large amount of information
· Graphs can be locked so when your selection changes the graph will not. You can then open additional graphs.
· You can choose the minimum and maximum number of cells to plot. This prevents the graph from updating as you move around in Excel
· Enjoy an easier and more intuitive interface than Excel charts
· Easily change the graph type
· Pick a row or column to use in the legend and series labels
· Choose from more colors than Excel Charts
· You can set up multiple graph themes that allow you to change multiple graph or chart characteristics instantly
· Graphing aka Charting has never been so easy!


Requirements:

· Microsoft Excel 2003
· Microsoft .NET Framework 2.0


Limitations:

· 15-day or 10-use trial

Devel::Graph module can turn Perl code into a graphical flowchart.

SYNOPSIS

use Devel::Graph;
my $grapher = Devel::Graph->new();

my $graph = $grapher->decompose( if ($b == 1) { $a = 9; } );
print $graph->as_ascii();

# Will result in something like this:

################
# start #
################
|
|
v
+--------------+
| if ($b == 1) |--+
+--------------+ |
| |
| true |
v |
+--------------+ |
| $a = 9; | | false
+--------------+ |
| |
| |
v |
################ |
# end # <+
################

# Alternatively, read in code from a file
my $graph_2 = $grapher->decompose( lib/Foo.pm );
print $graph_2->as_ascii();

This module decomposes Perl code into blocks and generates a Graph::Flowchart object out of these. The resulting object represents the code in a flowchart manner and it can return an Graph::Easy object.

This in turn can be converted it into all output formats currently supported by Graph::Easy, namely HTML, SVG, ASCII art, Unicode art, graphviz code (which then can be rendered as PNG etc) etc.

Graph::ModularDecomposition is a Perl module for modular decomposition of directed graphs.

SYNOPSIS

use Graph::ModularDecomposition qw(pairstring_to_graph tree_to_string);
my $g = new Graph::ModularDecomposition;

my $h = $g->pairstring_to_graph( ab,ac,bc );
print "yesn" if check_transitive( $h );
print "yesn" if $h->check_transitive; # same thing
my $m = $h->modular_decomposition_EGMS;
print tree_to_string( $m );

This module extends Graph::Directed by providing new methods related to modular decomposition.

The most important new method is modular_decomposition_EGMS(), which for a directed graph with n vertices finds the modular decomposition tree of the graph in O(n^2) time. Method tree_to_string() may be useful to represent the decomposition tree in a friendlier format; this needs to be explicitly imported.

If you need to decompose an undirected graph, represent it as a directed graph by adding two directed edges for each undirected edge.

The method classify() uses the modular decomposition tree to classify a directed graph as non-transitive, or for transitive digraphs, as series-parallel (linear or parallel modules only), decomposable (not series-parallel, but with at least one non-primitive module), indecomposable (primitive), decomposable but consisting of primitive or series modules only (only applies to graphs of at least 7 vertices), or unclassified (should never apply).

Graph CoOrdinates description
Graph CoOrdinates was written in order to allow Excel to easily find the co-ordinates of any point on an XY (Scatter) graph Graph CoOrdinates was developed for allowing MS Excel to simply search and find the co-ordinates of any point on an XY (Scatter) graph.

Currently Excel will show the co-ordinates of a data point on a series, but if there is no data point at the location you want to find, it is not so easy.

Graph any explicit or implicit relation or inequality in rectangular or polar coordinates. Explicit graphing (y=, r=, etc) is instant, but implicit relations are graphed with brute force, and may take a few seconds.

Basically, this will graph ANY equation or inequality that contains an x, y, r, or t (theta). It does not have to be in a y= format.