Free line graphs software for linux

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.

GOBLIN is a C++ class library focussed on graph optimization and network programming problems. GOBLIN Graph Library deals with all of the standard graph optimization problems discussed by textbooks and in courses on combinatorial optimization.
This software package also consists of a shell interpreter which extends the well-known Tcl/Tk language to graph objects and a graph browser and editor tool. Executable solvers are available for practical optimization problems. The graph browser applies for teaching and scientific documentation purposes.
GOBLIN is open source software and licenced by the GNU Lesser Public License (LGPL). That is, GOBLIN may be downloaded, compiled and used for scientific, educational and other purposes free of charge. For details, in particular the statements about redistribution and changes of the source code, observe the LGPL document which is attached to the package.
Main features:
- The gosh interpreter extends the Tcl/Tk scripting language to graph objects in a natural way.
- The goblet graph browser and editor tool. Graphical front end to the library.
- An open class hierarchy which strictly separates between abstract classes (all mathematical algorithms are defined as methods of abstract classes), implementations (i.e. by incidence lists, adjacency matrices) and logical views (problem transformations).
- A generic branch and bound module with several applications to graph optimization.
- Logging and tracing functionality which allows to study the various algorithms by examples.
- A runtime configuration module controls the selection of mathemetical methods, logging information, and the tracing of data objects.
- Compile time configuration module for code optimization.
- A file interface which can be easily extended to new problem classes.
- Source code for executable solver programs.
Today, GOBLIN provides strongly polynomial algorithms for the following graph optimization problems:
- Shortest paths in graphs and digraphs with negative lengths.
- Negative cycles and minimum mean cycles.
- Strong and 2-connected components.
- Minimum spanning trees, arborescences and 1-trees.
- Maximum st-flows, feasible circulations and b-flows.
- Min-cost st-flows, b-flows and circulations.
- Assignment problems of any kind.
- 1-matchings, b-matchings, capacitated b-matchings, f-factors and degree-constrained subgraphs.
- Directed and undirected Chinese postman problems, T-joins.
Enhancements:
- This release comes with explicit code for orthogonal drawing of trees.
- There are also new generator methods for regular planara graphs.
- A lot of doxygen comments has been added, but dexcription are still far from complete.

JpGraph makes it easy to draw both "quick and dirty" graphs with a minimum of code and complex professional graphs which requires a very fine grain control.
The library assigns context sensitive default values for most of the parameters which minimizes the learning curve. The features are there when you need it - they dont get in your way. The JpGraph library also comes wih very extensive documentation.
Main features:
- Web-friendly, average image size for a 300*200 image is around 2K and images are seldomly bigger than 4-5K
- Support for both GD1 and GD2 The library will autodetect which library is installed.
- Automatic generation of client side image maps to make it possible to generate drill-down graphs.
- Advanced interpolation with cubic splines to get smooth curves from just a few data points.
- Advanced support to add text to images with multi-line paragraphs and formatting support in several TTF fonts.
- Support for alpha blending
- has over 200+ built in Country flags
- Support automatic timing of images.
- Supports adding arbitrary lines and filled areas (with patterns) to plots
- Supports several plot types,spider-plots, pie-charts (both 2d and 3d) , scatter-plots, line-plots, filled line-plots, accumulated line-plots, bar plots, accumulated bar plots, grouped bar plots, error plots, line error plots, box plots, stock plots
- Supports advanced Gantt-charts (ex1, ex2)
- Flexible scales, supports text-lin, text-log, lin-lin, lin-log, log-lin and log-log
- Supports integer scale (labels are restricted to integers).
- Supports both PNG, GIF and JPG graphic formats. and can automatically choose the best available graphic format. Note that the available formats are dependent on the specific PHP installation where the library is used.
- Support various layout with a background image behind the plot
- Supports horizontal bar graphs
- Supports scientific plots
- More than 400 named colors
- Several possible axis positions
- Supports caching (with timeout) of generated graphs to lessen burden of a HTTP server.
- Intelligent autoscaling which gravitates towards aesthetical values.
- Fully supports manual scaling, with fine grain control of position of ticks
- Several different fill styles for line plots
- Supports up to two different y-scales, it is possible to have different left and right y-scale and add plots to both
- Supports unlimited number of plots in each graph, makes it easy to compose complex graph which consists of several plot types
- Designed as a flexible OO framework which makes it easy to add new types of plots
- Supports anti-aliasing of lines, more ...
- Supports color-gradient fill for bar graphs
- Supports automatic legend generation with user supplied format.
- Supports both vertical and horizontal grids (with image depth specification)
- Supports both on-the fly image generation and batch processing.
- Includes graph module to make it very easy to draw arbitrary shapes using custom scale on a canvas including Bezier-curves with full support for all the features of JpGraph (including caching and timeout).x
- Barcode generation The professional version includes a Barcode module that makes it easy to generate barcodes in all commonly used symbologies.
- Designed modularly - you dont have to include code which isnt used. JpGraph Architecture Block diagram
- extensive documentation with both a 150 pages tutorial and an extensive class reference.
- ... and many, many more features
Enhancements:
- This release follows the PHP4 version with functionality and defect fixes.
- 7x4 LED-like displays have been added.
- A long-standing issue with user-defined pie colors and legends has been fixed.
- There are various bugfixes.

Command Line WRAPper is a tool that provides an easy way to build and run commands from input lines, avoiding the use of shell script. It is similar to xargs.

clwrap can make great things with the locate command, and is low resource intensive. It can also do some not-quite-fun works like multiple configure/make/make install after a fresh system installation. In practice, you have to generate a list of files/directories you want to manage, clwrap takes it in standard input and apply the command you want to apply for each files (lines) in input.

But you can do much more, in fact, its up to you to find how to use it ;).

examples:

- copying several files into one specific directory:

locate myfiles | clwrap -e cp {} mydir/

- renaming several files:

ls -1 ultra*
| clwrap -e "echo -n mv -v {}" -e "echo {} | sed s/ultra/ /"
| clwrap -e {}

- running a specific line in the shell history:

history | grep "482" | head -n 1 | sed s/ *[0-9]* *// | clwrap -v -e {}


- try all tv norms and frequency tables possible combinations with scantv:

cat norm
| clwrap -e "cat freq | clwrap -e echo scantv -n {} -f {}"
| clwrap -e {} > file 2>&1

- reformat source code, after a backup of course:

ls -1 | clwrap -e "cp {} {}.orig && flip -u {} && cat {}
| sed s/^[ t]*$//;/^$/d
| indent -kr -bad -bap -bbb -sob -i8 -l100 {} -o {}.tmp
&& mv {} tmp && mv {}.tmp {}"

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.

Python Call Graph (pycallgraph) is a Python library that creates call graphs for Python programs

pycallgraph is quite new. It seems to work well and I will most likely improve it in the near future!

Genealogy Graph Generator (GGG) is a set of programs for automatically generating academic genealogy graphs. It tells you who your advisor and your advisors advisor and her advisor and so on are.