graph weighted
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 732
Graph::Weighted 0.1301
Graph::Weighted is an abstract, weighted graph implementation. more>>
Graph::Weighted is an abstract, weighted graph implementation.
SYNOPSIS
use Graph::Weighted;
$g = Graph::Weighted->new(
data => [
[ 0, 1, 2, 0, 0 ], # A vertex with two edges.
[ 1, 0, 3, 0, 0 ], # "
[ 2, 3, 0, 0, 0 ], # "
[ 0, 0, 1, 0, 0 ], # A vertex with one edge.
[ 0, 0, 0, 0, 0 ] # A vertex with no edges.
]
);
$g = Graph::Weighted->new(
data => {
weight => {
a => { b => 1, c => 2 }, # A vertex with two edges.
b => { a => 1, c => 3 }, # "
c => { a => 2, b => 3 }, # "
d => { c => 1 }, # A vertex with one edge.
e => {} # A vertex with no edges.
}
foo => [
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
],
}
);
$g = Graph::Weighted->new(
data => $Math_Matrix_object,
retrieve_as => ARRAY,
);
$data = $g->weight_data;
$w = $g->graph_weight;
$w = $g->vertex_weight($v1);
$w = $g->vertex_weight($v1, $w + 1);
$w = $g->edge_weight($v1, $v2);
$w = $g->edge_weight($v1, $v2, $w + 1);
$vertices = $g->heaviest_vertices;
$vertices = $g->lightest_vertices;
$w = $g->max_weight; # Weight of the largest vertices.
$w = $g->min_weight; # Weight of the smallest vertices.
# Call the weight methods of the inherited Graph module.
$x = $g->MST_Kruskal;
$x = $g->APSP_Floyd_Warshall;
$x = $g->MST_Prim($p);
<<lessSYNOPSIS
use Graph::Weighted;
$g = Graph::Weighted->new(
data => [
[ 0, 1, 2, 0, 0 ], # A vertex with two edges.
[ 1, 0, 3, 0, 0 ], # "
[ 2, 3, 0, 0, 0 ], # "
[ 0, 0, 1, 0, 0 ], # A vertex with one edge.
[ 0, 0, 0, 0, 0 ] # A vertex with no edges.
]
);
$g = Graph::Weighted->new(
data => {
weight => {
a => { b => 1, c => 2 }, # A vertex with two edges.
b => { a => 1, c => 3 }, # "
c => { a => 2, b => 3 }, # "
d => { c => 1 }, # A vertex with one edge.
e => {} # A vertex with no edges.
}
foo => [
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
],
}
);
$g = Graph::Weighted->new(
data => $Math_Matrix_object,
retrieve_as => ARRAY,
);
$data = $g->weight_data;
$w = $g->graph_weight;
$w = $g->vertex_weight($v1);
$w = $g->vertex_weight($v1, $w + 1);
$w = $g->edge_weight($v1, $v2);
$w = $g->edge_weight($v1, $v2, $w + 1);
$vertices = $g->heaviest_vertices;
$vertices = $g->lightest_vertices;
$w = $g->max_weight; # Weight of the largest vertices.
$w = $g->min_weight; # Weight of the smallest vertices.
# Call the weight methods of the inherited Graph module.
$x = $g->MST_Kruskal;
$x = $g->APSP_Floyd_Warshall;
$x = $g->MST_Prim($p);
Download (0.011MB)
Added: 2007-08-07 License: Perl Artistic License Price:
812 downloads
Graph::Writer::DrGeo 0.01
Graph::Writer::DrGeo can save the graph output DrGeo scheme script. more>>
Graph::Writer::DrGeo can save the graph output DrGeo scheme script.
SYNOPSIS
my $g = new Graph;
# Add some vertices/edges to $g
my $writer = Graph::Writer::DrGeo->new();
$writer->write_graph($g,"graph.scm");
# graph.scm can be evaluated and rendered with Dr.Geo
Dr. Geo is a GTK interactive geometry software. It allows one to create geometric figure plus the interactive manipulation of such figure in respect with their geometric constraints. It is useable in teaching situation with students from primary or secondary level.
Besides the general file format, Dr.Geo also provide a dynamic graph definition using the language of Scheme. This module save any Graph object into Scheme language, which can be evaluated and rendered in Dr.Geo.
So far the default layout is the circle layout, more kind of layout could be added, and patches welcome.
<<lessSYNOPSIS
my $g = new Graph;
# Add some vertices/edges to $g
my $writer = Graph::Writer::DrGeo->new();
$writer->write_graph($g,"graph.scm");
# graph.scm can be evaluated and rendered with Dr.Geo
Dr. Geo is a GTK interactive geometry software. It allows one to create geometric figure plus the interactive manipulation of such figure in respect with their geometric constraints. It is useable in teaching situation with students from primary or secondary level.
Besides the general file format, Dr.Geo also provide a dynamic graph definition using the language of Scheme. This module save any Graph object into Scheme language, which can be evaluated and rendered in Dr.Geo.
So far the default layout is the circle layout, more kind of layout could be added, and patches welcome.
Download (0.008MB)
Added: 2006-07-19 License: Perl Artistic License Price:
1193 downloads
Graph 0.81
Graph is a Perl module with graph data structures and algorithms. more>>
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(...)
<<lessSYNOPSIS
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(...)
Download (0.12MB)
Added: 2007-07-02 License: Perl Artistic License Price:
1427 downloads
phpGraphEd 1.1
phpGraphEd is a perfect and very easy-to-use graph drawing class which is created for php. more>>
phpGraphEd 1.1 is a perfect and very easy-to-use graph drawing class which is created for php. It has support for groups, transparent everything, borders, etc. The graphs it renders (in GD format) can be outputted for low resolution monitor viewing or high resolution printing. It was written due to a need for a high resolution graph class at the office and released to the public domain under the GPL license to repay others for the software we ourselves have used free of charge.
Requirements:
- PHP 4+
- Bundled GD
- Some TTF fonts (not included for space reasons)
Added: 2007-10-16 License: GPL Price: FREE
1 downloads
Other version of phpGraphEd
phpGraphEd is a graph drawing class for php. It has support for groups, transparent everything ... to a need for a high resolution graph class at the office and released to the public domain underLicense:GPL (GNU General Public License)
Q-Graph 1.4
Q-Graph is a collection of Q scripts that provide a graph data structure and a full-featured graph editor. more>>
Q-Graph is a collection of Q scripts that provide a graph data structure and a full-featured graph editor (the latter requires Tcl/Tk).
Q-Graph library can be used to implement and test graph algorithms using the Q language.
Q is a functional programming language based on term rewriting. Thus, a Q program or "script" is simply a collection of equations which are used to evaluate expressions in a symbolic fashion.
The equations establish algebraic identities and are interpreted as rewriting rules in order to reduce expressions to "normal forms".
For instance, here is how you define a function sqr which squares its argument by multiplying it with itself:
sqr X = X*X;
Note that, as in Prolog, capitalized identifiers are used to indicate the variables in an equation, which are bound to the actual values when an equation is applied. Equations may also include a condition part, as in the following definition of the factorial function:
fact N = N*fact (N-1) if N>0;
= 1 otherwise;
Functions on structured arguments are defined by "pattern matching". E.g., the product of a list (denoted in Prolog-like syntax) can be computed with these two equations:
prod [] = 1;
prod [X|Xs] = X*prod Xs;
With this definition, the factorial can now also be defined as follows (the notation [1..N], as in Haskell, denotes an arithmetic sequence):
fact N = prod [1..N];
As you can see, the definitions are really just like mathematical equations. The syntax is superficially similar to other modern functional languages like Miranda and Haskell, except that Q is "free-format", i.e., it does not use layout to indicate syntactical structure (thus the semicolon is used to terminate an equation).
Due to its term rewriting heritage, Q goes well beyond most other functional languages in that it also allows you to perform computations with symbolic expressions. For instance, with the definition of the sqr function from above, you will find that sqr (X+1) evaluates to (X+1)*(X+1). This might first look like an arcane feature, but it is actually quite useful, because you can try your definitions with symbolic inputs, too.
<<lessQ-Graph library can be used to implement and test graph algorithms using the Q language.
Q is a functional programming language based on term rewriting. Thus, a Q program or "script" is simply a collection of equations which are used to evaluate expressions in a symbolic fashion.
The equations establish algebraic identities and are interpreted as rewriting rules in order to reduce expressions to "normal forms".
For instance, here is how you define a function sqr which squares its argument by multiplying it with itself:
sqr X = X*X;
Note that, as in Prolog, capitalized identifiers are used to indicate the variables in an equation, which are bound to the actual values when an equation is applied. Equations may also include a condition part, as in the following definition of the factorial function:
fact N = N*fact (N-1) if N>0;
= 1 otherwise;
Functions on structured arguments are defined by "pattern matching". E.g., the product of a list (denoted in Prolog-like syntax) can be computed with these two equations:
prod [] = 1;
prod [X|Xs] = X*prod Xs;
With this definition, the factorial can now also be defined as follows (the notation [1..N], as in Haskell, denotes an arithmetic sequence):
fact N = prod [1..N];
As you can see, the definitions are really just like mathematical equations. The syntax is superficially similar to other modern functional languages like Miranda and Haskell, except that Q is "free-format", i.e., it does not use layout to indicate syntactical structure (thus the semicolon is used to terminate an equation).
Due to its term rewriting heritage, Q goes well beyond most other functional languages in that it also allows you to perform computations with symbolic expressions. For instance, with the definition of the sqr function from above, you will find that sqr (X+1) evaluates to (X+1)*(X+1). This might first look like an arcane feature, but it is actually quite useful, because you can try your definitions with symbolic inputs, too.
Download (0.085MB)
Added: 2006-02-09 License: GPL (GNU General Public License) Price:
1352 downloads
Graph::Writer::TGXML 0.01
Graph::Writer::TGXML is a Perl module used to write out directed graph as TouchGraph LinkBrowser XML. more>>
Graph::Writer::TGXML is a Perl module used to write out directed graph as TouchGraph LinkBrowser XML.
SYNOPSIS
use Graph;
use Graph::Writer::TGXML;
$graph = Graph->new();
# add edges and nodes to the graph
$writer = Graph::Writer::TGXML->new();
$writer->write_graph($graph, mygraph.xml);
Graph::Writer::TGXML is a class for writing out a directed graph in a format suitable for use with TouchGraphs LinkBrowser. The graph must be an instance of the Graph class, which is actually a set of classes developed by Jarkko Hietaniemi.
The XML format contains Nodes and Edges. For nodes, the label, URL and tooltip attributes are used, for label, url and hint respectively. For edges, no attributes are currently used.
METHODS
new()
Constructor - generate a new writer instance.
$writer = Graph::Writer::TGXML->new();
This doesnt take any arguments.
write_graph()
Write a specific graph to a named file:
$writer->write_graph($graph, $file);
The $file argument can either be a filename, or a filehandle for a previously opened file.
<<lessSYNOPSIS
use Graph;
use Graph::Writer::TGXML;
$graph = Graph->new();
# add edges and nodes to the graph
$writer = Graph::Writer::TGXML->new();
$writer->write_graph($graph, mygraph.xml);
Graph::Writer::TGXML is a class for writing out a directed graph in a format suitable for use with TouchGraphs LinkBrowser. The graph must be an instance of the Graph class, which is actually a set of classes developed by Jarkko Hietaniemi.
The XML format contains Nodes and Edges. For nodes, the label, URL and tooltip attributes are used, for label, url and hint respectively. For edges, no attributes are currently used.
METHODS
new()
Constructor - generate a new writer instance.
$writer = Graph::Writer::TGXML->new();
This doesnt take any arguments.
write_graph()
Write a specific graph to a named file:
$writer->write_graph($graph, $file);
The $file argument can either be a filename, or a filehandle for a previously opened file.
Download (0.004MB)
Added: 2007-06-18 License: Perl Artistic License Price:
863 downloads
Graph::Flowchart 0.10
Graph::Flowchart is a Perl module that can generate easily flowcharts as Graph::Easy objects. more>>
Graph::Flowchart is a Perl module that can generate easily flowcharts as Graph::Easy objects.
SYNOPSIS
use Graph::Flowchart;
my $flow = Graph::Flowchart->new();
print $flow->as_ascii();
This module lets you easily create flowcharts as Graph::Easy objects. This means you can output your flowchart as HTML, ASCII, Boxart (unicode drawing) or SVG.
Classes
The nodes constructed by the various add_* methods will set the subclass of the node according to the following list:
start
The start block.
end
The end block, created by finish().
block
Orindary code blocks, f.i. from $b = 9;.
if, for, while, until
Blocks for the various constructs for conditional and loop constructs.
sub
For sub routine declarations.
use
For use, no and require statements.
goto, break, return, next, last, continue
Blocks for the various constructs for jumps/returns.
true, false, goto, call, return, break, next, continue
Classes for edges of the true and false if-branches, and for goto, as well as sub routine calls.
Each class will get some default attributes, like if constructs having a diamond-shape.
You can override the graph appearance most easily by changing the (sub)-class attributes:
my $chart = Graph::Flowchart->new();
$chart->add_block($a = 9;);
$chart->add_if_then($a == 9;, $b = 1;);
$chart->finish();
my $graph = $chart->as_graph();
Now $graph is a Graph::Easy object and you can manipulate the class attributes like so:
$graph->set_attribute(node.if, fill, red);
$graph->set_attribute(edge.true, color, green);
print $graph->as_html_file();
This will color all conditional blocks red, and edges that represent the true branch green.
<<lessSYNOPSIS
use Graph::Flowchart;
my $flow = Graph::Flowchart->new();
print $flow->as_ascii();
This module lets you easily create flowcharts as Graph::Easy objects. This means you can output your flowchart as HTML, ASCII, Boxart (unicode drawing) or SVG.
Classes
The nodes constructed by the various add_* methods will set the subclass of the node according to the following list:
start
The start block.
end
The end block, created by finish().
block
Orindary code blocks, f.i. from $b = 9;.
if, for, while, until
Blocks for the various constructs for conditional and loop constructs.
sub
For sub routine declarations.
use
For use, no and require statements.
goto, break, return, next, last, continue
Blocks for the various constructs for jumps/returns.
true, false, goto, call, return, break, next, continue
Classes for edges of the true and false if-branches, and for goto, as well as sub routine calls.
Each class will get some default attributes, like if constructs having a diamond-shape.
You can override the graph appearance most easily by changing the (sub)-class attributes:
my $chart = Graph::Flowchart->new();
$chart->add_block($a = 9;);
$chart->add_if_then($a == 9;, $b = 1;);
$chart->finish();
my $graph = $chart->as_graph();
Now $graph is a Graph::Easy object and you can manipulate the class attributes like so:
$graph->set_attribute(node.if, fill, red);
$graph->set_attribute(edge.true, color, green);
print $graph->as_html_file();
This will color all conditional blocks red, and edges that represent the true branch green.
Download (0.034MB)
Added: 2007-07-06 License: Perl Artistic License Price:
845 downloads
B::Graph 0.51
B::Graph is a Perl compiler backend to produce graphs of OP trees. more>>
B::Graph is a Perl compiler backend to produce graphs of OP trees.
SYNOPSIS
perl -MO=Graph,-text prog.pl >graph.txt
perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg
perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps
This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).
OPTIONS
Like any other compiler backend, this module needs to be invoked using the O module to run correctly:
perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";
Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.
Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):
-text, -vcg, -dot
Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).
-addrs, -no_addrs
Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.
-compile_order, -run_order
The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.
-SVs, -no_SVs
If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.
-ellipses, -rhombs
The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).
-stashes, -no_stashes
The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.
-fileGVs, -no_fileGVs
Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.
-SEQs, -no_SEQs
As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).
-types, -no_types
B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.
-float, -no_float
Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.
-targlinks, -no_targlinks
Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.
<<lessSYNOPSIS
perl -MO=Graph,-text prog.pl >graph.txt
perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg
perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps
This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).
OPTIONS
Like any other compiler backend, this module needs to be invoked using the O module to run correctly:
perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";
Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.
Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):
-text, -vcg, -dot
Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).
-addrs, -no_addrs
Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.
-compile_order, -run_order
The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.
-SVs, -no_SVs
If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.
-ellipses, -rhombs
The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).
-stashes, -no_stashes
The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.
-fileGVs, -no_fileGVs
Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.
-SEQs, -no_SEQs
As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).
-types, -no_types
B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.
-float, -no_float
Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.
-targlinks, -no_targlinks
Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.
Download (0.012MB)
Added: 2007-06-26 License: Perl Artistic License Price:
851 downloads
ibargraph 0.2
ibargraph provides a tool which shows the throughput on an ISDN line as a bar graph. more>>
ibargraph provides a tool which shows the throughput on an ISDN line as a bar graph.
This program shows the current throughput on an ISDN line as LED bar graph with LCDProc. Currently, this feature is only supported via the HD44780 extended display driver connect with the LCDTime wiring.
<<lessThis program shows the current throughput on an ISDN line as LED bar graph with LCDProc. Currently, this feature is only supported via the HD44780 extended display driver connect with the LCDTime wiring.
Download (0.008MB)
Added: 2007-04-24 License: GPL (GNU General Public License) Price:
913 downloads
GENE Graph Export Engine 0.3
GENE Graph Export Engine is an advanced XML exporter. more>>
GENE Graph Export Engine is an advanced XML exporter.
GENE Graph Export Engine is a complex convertor/framework for multi-namespace XML transforming and exporting.
It is able to convert various XML types including SVG, DocBook, MathML, XSL-FO, and their combinations into a wide area of output formats: PDF, PNG, SVG, PS, MIF, RTF, and XHTML.
Custom XSLT scripts can be registered easily and are used automatically. It requires Sun JRE 5.0.
Enhancements:
- GENE Core bugfixes. FOP plugin bugfixes.
- Gene Runner I18N support has been added. l12n in Slovak.
- Configuration ability has been added.
- New command line switches have been added.
- Preliminary buggy CML (Chemical Markup Language) and XHTML->DocBook exporters have been added.
<<lessGENE Graph Export Engine is a complex convertor/framework for multi-namespace XML transforming and exporting.
It is able to convert various XML types including SVG, DocBook, MathML, XSL-FO, and their combinations into a wide area of output formats: PDF, PNG, SVG, PS, MIF, RTF, and XHTML.
Custom XSLT scripts can be registered easily and are used automatically. It requires Sun JRE 5.0.
Enhancements:
- GENE Core bugfixes. FOP plugin bugfixes.
- Gene Runner I18N support has been added. l12n in Slovak.
- Configuration ability has been added.
- New command line switches have been added.
- Preliminary buggy CML (Chemical Markup Language) and XHTML->DocBook exporters have been added.
Download (1.1MB)
Added: 2006-07-03 License: MPL (Mozilla Public License) Price:
1209 downloads
graph-tool 0.9
graph-tool is a program to help with statistical analysis of graphs. more>>
graph-tool project is a program to help with statistical analysis of graphs.
Main features:
- support for directed and undirected graphs
- support for arbitrary vertex or edge properties
- generic filtering of edges and vertices
- several statistical measurements:
- degree (or scalar property) histogram
- vertex-vertex degree (or scalar property) correlation
- average nearest neighbours degree (or scalar property)
- vertex-edge-vertex correlation
- clustering coefficients
- assortativity coefficient
- average distance
- component statistics
- generation of random graphs with arbitrary degree distribution and degree correlation
- graph history measurement based on filtering
- support for graphml and dot file formats
The core algorithms are written in C++, making use of the Boost Graph Library, and template metaprogramming techniques, with performace in mind. The command line interface and other outlying code are written in python.
<<lessMain features:
- support for directed and undirected graphs
- support for arbitrary vertex or edge properties
- generic filtering of edges and vertices
- several statistical measurements:
- degree (or scalar property) histogram
- vertex-vertex degree (or scalar property) correlation
- average nearest neighbours degree (or scalar property)
- vertex-edge-vertex correlation
- clustering coefficients
- assortativity coefficient
- average distance
- component statistics
- generation of random graphs with arbitrary degree distribution and degree correlation
- graph history measurement based on filtering
- support for graphml and dot file formats
The core algorithms are written in C++, making use of the Boost Graph Library, and template metaprogramming techniques, with performace in mind. The command line interface and other outlying code are written in python.
Download (0.27MB)
Added: 2006-08-08 License: GPL (GNU General Public License) Price:
1178 downloads
CvsGraph 1.6.1
CvsGraph is a graph generator for files in CVS repositories. more>>
CvsGraph is a utility to make a graphical representation of all revisions and branches of a file in a CVS/RCS repository.
CvsGraph project has been inspired by the graph option in WinCVS, but I could not find a stand-alone version of this graph code. So, it was time to write one.
Enhancements:
- Merge lines between branches with the same parent were drawn cross-over.
- These were made easier to see by forcing them to originate on one side of the revision boxes.
<<lessCvsGraph project has been inspired by the graph option in WinCVS, but I could not find a stand-alone version of this graph code. So, it was time to write one.
Enhancements:
- Merge lines between branches with the same parent were drawn cross-over.
- These were made easier to see by forcing them to originate on one side of the revision boxes.
Download (0.11MB)
Added: 2006-07-09 License: GPL (GNU General Public License) Price:
1203 downloads
Graph-includes 0.11
Graph-includes creates a graph of dependencies between source files and/or groups of source files. more>>
Graph-includes creates a graph of dependencies between source files and/or groups of source files, with an emphasis on getting readable and usable graphs even for large projects.
Graph-includes project is meant to be an helper tool for a refactoring effort. Usability of the dependency graphs are currently improved by customizable grouping of several source files into a single node, and transitive reduction of the graph.
Enhancements:
- Ported to non-Unix platforms (tested on Windows).
- This release has finally implemented/fixed node group coloring.
- A default path for system-includes lookup has been added.
<<lessGraph-includes project is meant to be an helper tool for a refactoring effort. Usability of the dependency graphs are currently improved by customizable grouping of several source files into a single node, and transitive reduction of the graph.
Enhancements:
- Ported to non-Unix platforms (tested on Windows).
- This release has finally implemented/fixed node group coloring.
- A default path for system-includes lookup has been added.
Download (0.020MB)
Added: 2005-12-07 License: GPL (GNU General Public License) Price:
1416 downloads
SVG::Graph 0.01
SVG::Graph is a Perl module to visualize your data in Scalable Vector Graphics (SVG) format. more>>
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.
<<lessSYNOPSIS
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.
Download (0.086MB)
Added: 2006-08-29 License: Perl Artistic License Price:
1155 downloads
DGS Graph 0.9.0
DGS Graph was created to provide an easy to install graphing script, capable of generating graphs for web presentation. more>>
DGS Graph was created to provide an easy to install graphing script, capable of generating graphs for web presentation.
<<less Download (0.024MB)
Added: 2006-05-04 License: GPL (GNU General Public License) Price:
1268 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above graph weighted search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
