Next: Gn-Gz Up: Linux Software Encyclopedia Previous: Fn-Fz Contents

Ga-Gm

Last checked or modified: Mar. 5, 1999

GA Playground: The Genetic Algorithm Playground is a general GA toolkit implemented in Java for experimenting with genetic algorithms and handling optimization problems. A source code distribution is available which requires JDK 1.1.5 or higher.
[http://www.aridolan.com/ga/gaa/gaa.html]
GABLE: The Geometric AlgeBra Learning Environment is a Matlab software package and tutorial for learning geometric or Clifford algebra. The package includes:

demonstrations of geometric products, outer products, and inner products, and the geometric operators that can be formed with them;

demonstrations of computations that can be done using geometric algebra, including projection and rejection, orthogonalization, interpolation of rotations, and intersection of linear offset spaces; and

demonstration of blades as representations of subspaces, and the use of meet and join to manipulate them.

[http://www.cgl.uwaterloo.ca/~smann/GABLE/]
Gabriel: A security package built to warn of possible network intrusions by detecting and identifying network probing. It was especially built as a counter to the SATAN weakness detector package. The features include:

gabriel_client, which reports to gabriel_server any detected excessive probing of any host on its network segment;

gabriel_server, which gathers data from clients and notifies the administrator of any probes;

install_gabriel_client, which installs and starts the monitor program across a network;

install_gabriel_server, which installs the server program;

a test script for package evaluation is SATAN is not installed; and

notification of administrator via custom reports, email and pager.

A source code distribution of this C package is freely available.
[http://www.lat.com/gabe.htm]
Gadfly: An SQL database implemented in Python. Gadfly provides relational database functionality entirely implemented in Python, supporting a large subset of the standard SQL functionality. It is appropriate for write-once, read-many database systems of moderate size and also for data preparation functions or as a data analysis tool. Gadfly supports:

persistent databases consisting of a collection of structured tables with indices as well as the subset of SQL for accessing and modifying those tables;

a log-based recovery protocol that allows committed operations of a database to be recovered even if the database isn't shut down in a proper mannner; and

a TCP/IP client/server mode where remote clients can access a Gadfly database over a TCP/IP network subject to configurable security mechanisms.

[http://www.chordate.com/gadfly.html]
GAG: A graphical boot manager that is loaded when a computer is turned on and allows for the choice of an operating system. The features of GAG include:

booting one of up to nine different operating systems;

booting OSs installed on primary or extended partitions on any available hard drive;

installation from almost all OSs;

self-installation in the first track of the hard disk or on a floppy, i.e. no separate partition needed;

a timer to boot a default OS;

optional password protection;

operation in a GUI mode requiring a VGA or better card;

hiding of primary partitions to allow the installation of more than one DOS and/or Windows OS on the same hard disk;

optional passwords for each available OS;

a choice of several languages;

exchangeable disk drives that allow booting from the second, third, etc. disk OSs like DOS; and

a SafeBoot system that allows booting from the hard disk even if GAG is accidentally overwritten.

[http://raster.cibermillennium.com/gageng.htm]
GAGS: A genetic algorithm application generator and a class library written in C++. The application generator (written in Perl) creates a C++ program which uses the class library given an ANSI C or C++ fitness function as input. It also compiles it, runs it, saves the results, and presents them using Gnuplot. The latest version of GAGS (v. 0.94e) includes a GUI written in Tcl/Tk.
The class library includes:

a chromosome hierarchy with variable-length chromosomes;

genetic operators including 2-point crossover, uniform crossover, bit-flip mutation, and transposition;

variable-length operators;

population-level operators including steady state, roulette wheel and tournament selection; and

easy sample file loading and configuration file parsing.

The GAGS package is available as source code written in C++ and can be compiled using gcc 2.7.1 or later. It is documented in user's and programmer's manuals available in PostScript format.
[http://kal-el.ugr.es/GAGS]
GAIA: The Graphical Astronomy and Image Analysis tool is a Starlink Project package for the displaying of images which is also extensible via integrating other programs. The capabilities of GAIA include:

displaying images in FITS and Starlink NDF data formats (along with those which can be converted to one of these);

panning, zooming, data range, and color table manipulations;

continuous display of the cursor position and the image data value;

continuous display of RA and DEC coordinates for suitable images (i.e. FITS images with WCS headers);

displaying many images in separate windows;

colored annotation using text and line graphics;

printing the displayed image and annotations to a PostScript file;

real-time profiling;

real-time pixel value table display;

aperture photometry, i.e. a highly interactive environment for controlling the positions, sizes, and orientations of circular and elliptic apertures;

image patching with the capability of selecting arbitrary shaped regions on an image and replacing them with a surface fit to other regions;

interactive ARD regions which allow the calculation of statistics and the masking out and extraction of arbitrary shaped image sections;

and image blinking wherein an image series can be animated or cycled through by hand.

A binary distribution of GAIA is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. It is currently (6/97) sketchily documented in a brief user's guide available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
GAIO: The Global Analysis of Invariant Objects is a software package for the numerical analysis of dynamical systems. It can be used to compute attractors and invariant manifolds, invariant measures and almost invariant sets. It takes a set oriented approach to compute coverings of attractors and invariant manifolds. Statistical information about the dynamics is computed from the coverings. The methods work in arbitrary dimensions and the numerical effort depends only on the dimension of the object to be approximated. A source code distribution is available which can be installed on generic UNIX platforms with Tcl/Tk. A user's manual is included in the distribution.
[http://www-math.uni-paderborn.de/~agdellnitz/gaio/]
GAL: The Graphics Adaptor Language is a domain-specific language used to describe video device drivers. GAL specifications are an order of magnitude smaller than handwritten drivers and more readable. The allow state verifications as well as the automatic generation of the driver profile. The aspects of a video card specificied in GAL include:

probing the card configuration to, e.g. determine the amount of RAM;

unlocking the card;

setting the resolution;

panning;

setting the clock; and

the frame buffer.

A GAL driver written for the XFree86 SVGA X Window server is available in source code and binary formats for Linux.
[http://www.irisa.fr/compose/gal/]
GAlib: A C++ library that provides the application programmer with a set of genetic algorithm objects. It includes tools for using genetic algorithms to do optimization in any C++ program. The features include overlapping and non-overlapping populations, the capability of building chromosomes from any C++ data type, built-in termination methods, two speciation methods, optional elitism, several built-in chromosome types and replacement strategies, and much more. This can be compiled using the GCC/G++ compiler on Linux platforms.
[http://lancet.mit.edu/ga/]
Galley: A parallel file system designed for tightly-coupled multiprocessors and loosely-coupled networks of workstations. The system is composed of two main components: I/O processes (IOPs) and compute processes (CPs). The CPs are applications that interact with Galley by making calls into its run-time library which handles the communication and transfer of data between the CPs and IOPs. The IOPs are the I/O servers and are responsible for actually storing and retrieving data from some underlying storage medium. Standard UNIX files, raw devices or simulated disks can be used as the underlying medium. The features include:

support for many common access patterns included simple and nested striding;

complete control over parallelism;

a 3-D file structure;

support for libraries;

asynchronous I/O; and

low memory and computational overhead.

Galley is designed to be portable and has been used on several platforms including Linux Intel. Documentation includes a set of man pages.
[http://www.cs.dartmouth.edu/~nils/galley.html]
GALOPPS: The Genetic ALgorithm Optimized for Portability and Parallelism System is a flexible and generic genetic algorithm package written in C. It is based on the SGA-C package, i.e. the performance-critical parts of SGA-C were rewritten as a starting point for GALOPPS. GALOPPS can provide island parallelism in three types of architectures: a single PC simulating parallel subpopulation, multiple processes on a workstation, and multiple computers on a network.
The features of GALOPPS which extent SGA-C include:

a graphical user interface based on Tcl/Tk which can be used to monitor simulations;

the availability of several selection methods, e.g. roulette wheel, stochastic remainder sampling, tournament selection, stochastic universal sampling, and linear-ranking-then-SUS;

the random or superuniform initialization of ordinary binary or non-binary chromosomes, random initialization of permutation-based chromosomes, or user-supplied initialization of arbitrary types of chromosomes;

binary or non-binary alphabetic fields on value-based chromosomes;

three crossovers for value-based and 4 crossovers for order-based representations;

four mutations;

several fitness scaling options (e.g. linear scaling, Boltzmann scaling, sigma truncation, window scaling, and ranking);

optional automatic control of selection pressure;

optional elitism; and

nconvergence.

The GALOPPS distribution, written in C, is available in source code form for generic UNIX platforms as well as for PCs. There is also a version which runs on top of PVM. The package is documented in an 80+ page user's manual in PostScript format.
[http://GARAGe.cps.msu.edu/software/software-index.html]
GAM: A Fortran code to numerically solve first order ODEs, either stiff or non-stiff, in the form y' = f(x,y) with given initial conditions. GAM uses a set of methods called Boundary Value Methods (BVMs) called Generalized Adams Methods (GAMs) or order 3, 5, 7 and 9 with step-size control.
[http://www.dm.uniba.it/~mazzia/ode/readme.html]
Gambit: A high performance implementation of Scheme based on an optimizing compiler which conforms to both the IEEE Scheme standard and R4RS. Several extensions to the standards are also provided including:

a debugger with a stack inspection facility,

a foreign function interface for C,

a memory management system which grows and shrinks the heap based on program needs,

a linker that builds standalone executables and shared libraries,

the dynamic loading of compiled modules and libraries,

Unicode support,

object finalization,

pretty printing,

string ports,

bytevectors (i.e. uniform vectors of integers or floating point numbers),

record structures,

keyword objects,

optional and keyword parameters,

control over case sensitivity,

dynamic variables,

eval capability, and

Maclisp style macros.

Gambit implements the full numeric capabilities of Scheme including infinite precision integers, rationals, inexact reals, and complex numbers. The Gambit system consists of two programs: gsi, a Gambit Scheme Interpreter; and gsc, a Gambit Scheme Compiler which generates portable C code for further compilation by the native C compiler.
A source code distribution of Gambit is available for UNIX platforms. It is written in C and has been built successfully on many flavors of UNIX including Linux Intel.
[http://www.iro.umontreal.ca/~gambit/]
Gambit: A library of programs written in C++ for building, analyzing, and solving n-person games in either extensive or normal form. The programs can be called from standard C++ programs or accessed via either the Graphics User Interface (GUI) or the Gambit Command Language (GCL). The Gambit GUI consists of two self-contained modules for representing, displaying, and manipulating games. These modules allow a game to be viewed in either the extensive or normal form, and also to translate from the extensive to nromal form (although not vice-versa yet). The GCL is more suitable for repetitive or computer intensive operations which would be overly tedious with the GUI. The GUI and GCL are compatible in the sense that they each generate files that can be read by the other.
A source code distribution of Gambit is available as are binary versions for Windows 3.x/NT/95, Sun SunOS and Solaris, IBM RS/6000, HP-UX, and Linux Intel platforms. Compilation requires a C++ compiler which supports templates (e.g. GCC 2.6.2 or greater) and also the wxWindows package. The data plotting program PXI was designed to work with Gambit. Documentation is included in each distribution.
[http://www.hss.caltech.edu/~gambit/Gambit.html]
GAMMA: A C++ package for the construction of programs for simulating magnetic resonance phenomena. GAMMA consists of a library of subroutines tailored to deal with problems in magnetic resonance as well as a range of data types commonly used to formulate MR problems. The classes in GAMMA include:

complex, defines complex numbers and operations on them;

matrix, provides functions to create and manipulate matrices;

basis, maintains the bases needed for the algebraic manipulation of matrix-based data types;

operator, defines the attributes of a quantum mechanical operator;

super operator, defines the attributes of a quantum mechanical superoperator;

coord, for the manipulation of points in 3-D space;

coordinate vector, for the manipulation of a list of coordinate points;

isotope, defines the physical attributes of an isotope;

spin sys, defines the physical attributes of a system of spins;

spin system, defines the physical attributes of a system of spins subjected to a stationary external magnetic field;

spin tensor, for handling general tensors involving spin angular momentum;

space tensor, for handling general spatial tensors;

dynamic spin system, for manipulating dynamic spin systems;

acquire, the computational core needed for determining expectation values; and

quartern, a data type for quarternians.

Source code and binary distributions are available for several platforms including Linux Intel. Extensive documentation is avaialable in both PostScript and HTML format. See Smith et al. (1994).
[http://gamma.magnet.fsu.edu/]
GAMMA: The Genoa Active Message MAchine is a software package for fast Ethernet-connected pools of machines used either as a set of autonomous workstations or as an efficient parallel platform for SPMD or MIMD applications. The core of GAMMA is a custom device driver for 100base-T network cards under Linux. This driver delivers very low latency and high bandwidth communications using Active Ports, a mechanism that delivers both point-to-point and broadcast communications. The GAMMA driver handles both standard IP traffic and GAMMA fast communications traffic. The GAMMA communication mechanisms are made available to applications via the GAMMA library, which provides support for launching applications, process grouping, communications, and various collective routines.
[http://www.disi.unige.it/project/gamma/]
Gamora: The GNU Adaptable Multiplatform Object Routing Architecture is a project to develop an extensible, generic application server written in Java. It is a platform for quickly developing modular applications whose features include:

security based on thread-of-execution;

remote administration and application visualization;

transparent distributed application support;

thread management;

multi-application support; and

a convenient module abstraction.

Gamora uses Buses and BusObjects to provide an abstraction paradigm that is adaptable to as many modular programming tasks as possible. Functionality is divided into any number of Buses, i.e. components that host other components called BusObjects. This provides a method for the components to communicate via message passing. Since the Buses are also BusObjects they can be attached to other Buses to create a hierarchical structure. A second object classification scheme provides BusControllers, i.e. BusObjects registered with a Bus to receive anonymous messages. A method of associating state with connections is provided with Nodes, which are BusObjects with methods allowing other BusObjects to set and retrieve state.
A package built on top of Gamora to provide a generic communications architecture is Waterworks. This provides the ability to send and receive data to the network in any form. Waterworks extends the standard Java libraries with:

the ability to chain stream-processing modules with the additional advantages of hot-swapping and forking;

the ability to switch data sources and destinations at will without disrupting the resources;

the ability to provide sophisticated filter and logic modules, even those unrelated to the streams themselves; and

the ability of these modules (or Pipes) to disconnect themselves when finished or spawn new pipes with disrupting data flow.

The four main components comprising Waterworks are:

Sinks, BusObjects that hold and control a set of input and output pipes (i.e. the Waterworks);

Pipes, a communication element, i.e. a filter or datasource;

Factories, which build Sinks from a description of the Waterworks; and

Sinkbuilders, which repeatedly call Factories to build Sinks.

GAMORA distributions are freely available via the GPL. Documentation includes an architecture guide as well as details on the Java code in javadoc format.
[http://gamora.org/]
GAOT: The Genetic Algorithm Optimization Toolbox is a package implementing simulated evolution in the Matlab environment using genetic algorithms.
[http://www.ie.ncsu.edu/mirage/]
GAP: The Groups, Algebra and Programming System is designed for computational discrete algebra and developed with particular emphasis on computational group theory. It consists of several parts: the kernel, the library of functions, the library of groups and related data, and the documentation. The kernel implements a Pascal-like programming language (called, believe it or not, GAP) with special data types for computations in group theory. It also implements an interactive programming environment to run GAP programs. The function library contains implementations of various group theoretical algorithms written in the GAP language.
The distribution contains the C source code for the kernel, the GAP code for the library, and the LaTeX code for the manual (which stacks up to about 1100 pages as of 2/97). The kernel can be easily compiled on most UNIX systems with a C compiler.
[http://hurin.math.rwth-aachen.de/LDFM/GAP/]
[http://www-gap.dcs.st-and.ac.uk/~gap/]
[ftp://ftp.mth.pdx.edu/pub/math/gap/]
[ftp://pell.anu.edu.au/pub/gap/]
GAP: The GNU Administration Project is a new approach to system administration for heterogeneous networks. It plans to develop administration tools for:

managing large numbers of nodes as easily as a single machine;

providing a homogeneous layer for system administration;

automatically performing routine tasks;

providing a mechanism for easy extensibility; and

providing reusability such that existing tools and interfaces can be used.

[http://www.gsyc.inf.uc3m.es/~assman/gap/]
garbage collection: The FAQ defines garbage collection as ``part of a language's runtime system, or an add-on library, perhaps assisted by the compiler, the hardware, the OS, or any combination of the three, that automatically determines what memory a program is no longer using, and recycles it for other use.'' It is also known as ``automatic storage (or memory) reclamation.'' See Jones (1999) and also the memory management section for pointers to specific software packages.
Sites of interest include:

Garbage Collection FAQ
[http://www.iecc.com/gclist/GC-faq.html]

Dynamic Storage Allocation and Memory Management Information Repository
[http://www.cs.colorado.edu/~zorn/DSA.html]

The Memory Management Reference
[http://www.harlequin.com/products/st/mm/]

Uniprocessor Garbage Collection Techniques
[ftp://ftp.cs.utexas.edu/pub/garbage/bigsurv.ps]

Dynamic Storage Allocation: A Survey and Critical Review
[ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps]

Garbage Collection for C and C++
[http://reality.sgi.com/boehm/gc.html]

Gorik's Garbage Collection Page
[http://www.cs.rpi.edu/~gorik/garbage/]
GAS: See the binutils entry for more information on the GNU Assembler.
GASH: The Group Administration SHell is a special shell for for distributed NIS administration whcih has been designed to allow system administrators of non-NIS master systems to maintain subsets of the NIS databases. The administrator of the master NIS server appoints a user to be an NIS Group Administrator who is assigned a range of UIDs, GIDs, and netgroup names that can be assigned to new users, projects, or machines via GASH commands. GASH performs many complex tasks automatically and constrains GASH administrators to editing a restricted subset of the NIS and DNS maps according to their privileges. As such it allows relatively untrained personnel to safely perform a number of tedious administration tasks. The prototype implementation contains system information for 984 network devices (with 2011 total network interfaces) and NIS information for 614 users in 166 account groups, with more than 45 people having been granted GASH administration privileges.
The GASH system controls a single, comprehensive NIS domain in which all systems are part of the GASH Networked Computing Environment (NCE). It maintains basic user and group NIS maps as well as NIS maps to control the delivery of e-mail within the NCE. It maintains DNS tables as well as NIS maps, keeping Ethernet and Internet records for all systems. All IP address changes resulting from the physical movement of machines are handled by GASH. The NCE consists of a central server that maintains NIS and DNS tables, multiple NIS and DNS slave servers, and a number of NCE hosts. Changes to NIS and DNS tables are made on the main server and then propagated to to slave servers which in turn feed them to the NCE hosts.
A source code distribution for GASH is available. It is written in ANSI C and can be compiled and installed on many flavors of UNIX. It is documented in a user's manual as well as in a technical report. A newer and more powerful version of GASH called GANYMEDE is being developed.
[http://www.arlut.utexas.edu/csd/gash_docs/gash.html]
GASM: A freeware assembler whose features include:

direct support for protected mode to provide built-in structures for commonly used entities such as GDT entries and gates and TSS;

support for 16 and 32 bit modes;

fast compilation;

support for Intel assembly syntax;

support for the Intel instruction set including Pentium Pro instructions;

informative error output;

automatic correction routines; and

support for override prefixes.

A source code distribution is available under the GPL.
[http://www.gaztek.co.uk/gasm/]
GASP: See the binutils entry for more information on the GNU Assembler Preprocessor.
Gato: The Graph Animation TOolbox visualizes algorithms on graphs, where graphs are mathematical objects consisting of vertices and edges connecting them. The algorithms used include shortest path, minimal spanning tree, maximal-flow, weighted and non-weighted matching and min-cost flow. This was developed using Python and Tcl/Tk.
[http://www.zpr.uni-koeln.de/~gato/]
GATOS: The General ATI TV and Overlay Software project intends to create standard drivers for all currently (2/00) unsupported features of ATI video cards, specifically TV features. The GATOS distribution contains several programs including:

gatos-conf, a configuration program;

xatitv, a TV-in-a-window program that allows GUI access to all GATOS functionality;

atitv, a text-mode program for recording video and taking snapshots;

atitoppm, converts the internal GATOS file format into a series of PPM files;

atitogif, converts the internal GATOS file format into a series of GIF files;

atitojpg, converts the internal GATOS file format into a series of JPEG files;

yuvsum, averages all images in a GATOS YUV format file into a single PPM format image; and

atisplit, converts a YUV file into separate YUV frames.

[http://www.core.binghamton.edu/~insomnia/gatos/gatosfaq.html]
Gawk: A GNU package which implements a superset of the awk programming language. See Aho et al. (1988), Dougherty (1992), Dougherty and O'Reilly (1987), and Robbins (1996).
[http://www.gnu.ai.mit.edu/order/ftp.html]
Gazebo: A internet server software package that enables interoperable searches across multiple, distributed, heterogeneous data collections. Gazebo is designed to allow lightweight clients to query and browse results from multiple data sources simultaneously. It is similar to Z39.50 in that it's based on an abstract data and query model, but unlike the former it is also based on an abstract model of search attributes which map to parameters passed to the target data sources. This mapping can be used to express semantic equivalence between different metadata schemas and thus make possible interoperable search across heterogeneous data collections.
Gazebo can return records in any text format, and also provides a way of postprocessing recrods in any (including binary) format with external CGI scripts to convert them to a desired text format such as HTML. The Gazebo client interface is a simple language-neutral protocol based on XML. A client can use this protocol to discover Gazebo's search attribute space, perform queries, and receive results asynchronously. A toolkit provides an object-oriented interface to the protocol. The salient features include:

cross-disciplinary searching of scientific data as well as text;

support for nested boolean queries with administrator-defined query attributes;

multithreading for asynchrony;

support for multiple back-end protocols including Z39.50;

configurable via an XML-based configuration format;

a CGI interface for automatic record format conversion; and

the capability of serving applets for browsing results.

A source code distribution of this Java package is available. The Gazebo Client Toolkit is separately available. Documentation is still (3/99) being written, with some currently available.
[http://emerge.ncsa.uiuc.edu/]
gbeta: An interpreter for a generalization of the programming language BETA. The gbeta generalization is generally backwards compatible which allows old BETA programs to be executed. The most significant new feature is that types are computed via a constraint solving process. A source code version is available as well as binaries for HP-UX, Linux Intel, SGI IRIX, and Sun Solaris platforms.
[ftp://ftp.daimi.aau.dk/pub/empl/eernst/gbeta/]
GBIT: A package for the Good Broyden ITerative solution of a linear system. GBIT is a fast secant method (with adapted line search) for the iterative solution of large, nonsymmetric linear systems. This is written in Fortran 77 and documented via an ASCII text file as well as comment statements within the source code. This is part of CodeLib.
[ftp://elib.zib.de/pub/elib/codelib/gbit1/]
gbuild: A sh script written to simplify package maintenance. It automates code updating from CVS, package compilation, and includes preliminary support for building tar files, RPMs and SRPMs of a given package. This was designed and is used in the GNOME project and provides powerful interaction with the autoconf/automake tool families.
[http://cryon.com/gbuild/]
GBYTES: A library of programs to handle binary packing. There are versions available for most popular computer systems as well as Fortran and C versions that are applicable on many systems. This utilities greatly simplify the handling of packed-binary formats, word formats from other computers and other bit-groups which are not accessible directly in the executing computer.
[http://www.scd.ucar.edu/dss/softlib/gbytes.html]
GCC/gcc: The GNU C Compiler was developed by GNU to provide a free compiler for the GNU system. It is also occasionally known as GNU CC. GCC can compile programs written in C, C++, Objective C, Ada 95, Fortran 77, and Pascal. The command name used to invoke the compiler is gcc. The compiler is called G++ when is is used for compiling C++ programs GCC or GNU CC refers to the compilation system as a whole, and more specifically to the language-independent part of the compiler which is also known as the back-end.
The goal of GCC is to create a good and fast compiler for the type of machines at which the GNU project is aimed, i.e. 32-bit machines which address 8-bit types and have several general registers. It gets most of its information about a target machine from a description file giving an algebraic formula for each of the machine's instructions, a procedure designed to increase the portability of the compiler to the detriment of theoretical maximum performance. GCC doesn't contain machine dependent code but does contain code that depends on various machine parameters such as endian-ness.
In addition to being able to compile programs written in both ANSI C and K&R C, GCC provides several language features not found in the more recent ANSI C standard. All of the extensions are available in C and Objective C, and most of them in C++. The extensions include:

putting statements and declarations inside expressions,

labels local to a statement-expression,

getting pointers to labels and computed gotos,

lexical scoping of functions as in Algol and Pascal,

dispatching calls to other functions,

giving a name to the type of some expression,

a typeof statement referring to the type of some expression,

double-word integers (i.e. long long ints),

data types for complex numbers,

zero-length arrays,

arrays whose length is computed at run time,

macros with a variable number of arguments,

subscripting of any array,

arithmetic on void and function pointers,

non-constant initializers,

constructor expressions giving structures and unions,

labeling elements of initializers,

casting to union type from any member of the union,

case ranges,

declaring that functions have no side effects or they can never return,

prototype declarations and old-style definitions,

recognition of C++ comments,

specifying attributes of variables and types,

inquiring about the alignment of a type or variable,

defining inline functions as fast as macros,

assembler instructions with C expressions as operands,

specifying the assembler name to use for a C symbol,

defining variables residing in specified registers, and

printable strings which are the name of the current function.

The standard GCC distribution includes the compiler for C, C++ and Objective as well as the standard GNU C library. The GNU C++ library libg++ is available separately. A user's manual for GCC is available in Texinfo format as is a separate manual for libg++. Standard texts covering ANSI C can also be used as manuals.
[http://www.gnu.ai.mit.edu/software/gcc/gcc.html]
[http://sunsite.unc.edu/pub/Linux/GCC/]

bcc

A set of bounds checking extensions for GCC. This is available either in the form of patch files or precompiled binaries for various platforms including Linux Intel.
[http://www.doc.ic.ac.uk/~phjk/BoundsChecking.html]
GCJ: A front end to the GCC compiler that can natively compile both Java source and bytecode files. This is integrated into the egcs project. Currently (9/98) the package consists of:

gcj, a front end to GCC that can read Java class files and generate assembly code as well as serve as a front end for jvgenmain;

jvgenmain, a program for generating an appropriate main for a Java class;

gcjh, a program for generating C++ header files corresponding to Java class files;

jcf-dump, which reads a class file and prints out useful information about it; and

jv-scan, which reads a .java file and prints useful information about it.

The compiler cannot yet be used to generate actual executables until the runtime environment is included in the package.
[http://sourceware.cygnus.com/java/]
GCL: A Lisp implementation that includes a compiler and an interpreter for Common Lisp. It is portable and efficient on a wide class of applications. It currently (2/97) supports the CLtL1 specification but is moving towards the proposed ANSI definition. It is based on both AKCL and KCL. GCL compiles to C and then uses the native optimizing C compilers to create a executable. It has a conservative garbage collector (GC) and a source level Lisp debugger for interpreted code. It also has profiling tools based on the C profiling tools. It works with CLX and PCL and has an Xlib interface via C, all of which are available in the same FTP directory as the GCL distribution. GCL can be compiled on a large variety of platforms including Linux.
[http://sunsite.unc.edu/pub/Linux/devel/lang/lisp/]
GCL/MPI: A specification implementation of the STAR/MPI system (which allows the binding of MPI to a generic interactive language) for the GCL implementation of Common Lisp. It is intended to be an easy-to-use master-slave distributed architecture which combines the feedback of an interactive language, i.e. GCL, with the use of MPI to take advantage of networks of workstations. A goal is to make available an SMPD architecture which helps people overcome the initial learning barrier in writing parallel programs. As such, emphasis is place on ease of use while attempting to maintain reasonable efficiency and a reasonable feature set. This is an experimental software project which is available in a source code distribution. It is documented in a README file as well as (generically) in a technical report about STAR/MPI available in PostScript format.
ftp://ftp.ccs.neu.edu/pub/people/gene/starmpi/]
gcombust: A GUI for mkisofs and cdrecord written using GTK. The functionality includes:

burning on the fly from the hard drive without making an image;

CD-to-CD data copying on the fly;

interactive tooltips;

easy creation of ISO images, i.e. support for making a directory hierarchy on the image without needing to copy files and make symbolic links;

disk maximization by hinting which directories and files to use;

creation of audio CDs;

printing CD covers via cdlabelgen; and

support for creating bootable CDs.

[http://www.abo.fi/~jmunsin/gcombust/]
GCT: The Generic Coverage Tool is a coverage tool that measures how thoroughly tests exercise C programs. GCT can measure how often:

branches have been taken in either direction;

cases in switches have been taken;

nested logical conditions have evaluated to true and false;

loops have iterated zero, onee and more than one times;

the boundaries of relational operators have been probed;

routines have been entered;

call sites have been exercised; and

routines have had multiple threads of execution in them.

The tool adds instrumentation to C source code and then uses the compiler to produce an object file. It is designed to work with existing makefiles and stores coverage information in an internal log for efficiency. A source code distribution is available.
[ftp://cs.uiuc.edu/pub/testing/]
gd: A library that allows you to quickly draw images complete with lines, arcs, text, multiple colors, cut and paste from other images, and flood fills, and to write out the result as a .GIF file. This supplies most of the commonly requested features for a 2D graphics package, and support for the PNG graphics format is forthcoming. It is written in C but can also be used with the Tcl gd and Perl extensions.
[http://www.boutell.com/gd/]

tgd

A text-based tool for creating and manipulating GIF images that is based on the gd graphics library.
[http://dendrome.ucdavis.edu/tgd/]
GDAL: The Geospatial Data Abstraction Library is a translator library for raster geospatial data formats. It presents a single abstract data model to the calling application for all supported formats.
[http://www.remotesensing.org/gdal/]
GDB: The GNU DeBugger is a program that allows you to see what is going on inside another program while it executes or what a program was doing when it crashed and to (hopefully) help remove the bugs that crashed it. GDB can do four main types of things: start a program after specifying anything that might affect its behavior, make a program stop contingent on specified conditions, examine what happens when a program stops, and change things in a program to ameliorate undesirable behavior, i.e. bugs. GDB can be used to debug programs written in both C and C++ and provides partial support for debugging programs written in Modula-2, Chill, Pascal, and Fortran. It also has a special interface to Emacs which allows you to use that editor to view and edit the source files for the program you're debugging.
A source code distribution of GDB is available. It is written in C and can be compiled and installed on most platforms using the configure file supplied with the distribution. It is documented in a user's manual available in Texinfo format.
[http://www.cygnus.com/gdb/]
[http://www.gnu.org/manual/gdb/gdb.html]

gdbtk

A GUI for GDB built using the Tcl/Tk toolkit.
[ftp://ftp.cygnus.com/pub/gdbtk/]
[http://www.doc.ic.ac.uk/lab/labsrc_area/src/gdbtk/]

zgdb

A set of patches that add enhanced functionality to gdb including:

new data transfer commands that allow that contents of a variable to be extracted or updated efficiently;

a process identifier command;

a command for converting data into an architecture independent format (AIF); and

support for debugging the ZPL parallel programming language.

A set of source code patches for the standard gdb distribution is available.
[http://www.dgs.monash.edu.au/research/guard/gdb/]
gdbm: The GNU DataBase Manager is a library of database functions that use extensible hashing. This works similarly to the standard UNIX dbm functions. These routines can be used by a programmer to create and manipulate a hashed database, but do not in themselves constitute a complete database package for an end user. A source code version of gdbm is available. It is written in C and can be compiled via the supplied Autoconf script. A manual is included in Texinfo format.
[http://www.gnu.org/software/gdbm/gdbm.html]
GDCC: A parallel constraint logic programming language which is highly declarative, flexible and efficient, and can deal with various contraints including nonlinear polynomial equations. The GDCC system includes various constraint solver libraries and a language processor which translates GDCC programs to KL1. It parallelizes both logic language and constraint solvers and enables the description of what (declarative knowledge) without how (procedural knowledge).
A source code distribution of GDCC is available. It is written in C and translates GDCC programs into KL1, thus requiring that KLIC also be installed. A manual is included in the distribution. This software is part of the ICOT project.
[http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/icot/kbms_clp/pimos/]
GDE: A set of programs for multiple sequence alignment and analysis that use an extensible user interface allowing the addition of external analysis functions without code rewriting. The functionality includes:

translating DNA/RNA sequences to amino acid;

displaying dotplot identity matrices for sequences;

aligning sequences using the clustav algorithm;

searching and highlighting sequences for substrings;

scoring sequences column by column for conservation;

returning the concensus for a sequence;

calculating a distance matrix for a sequence;

folding a sequence using MFOLD;

drawing a sequence using a proposed secondary structure;

showing all violations to a proposed RNA secondary structure;

searching a sequence against a given database using a selection of tools.

Source and Linux binary distributions are available as is a user's manual.
[ftp://ftp.bmc.uu.se/pub/linnaeus/software/gde/]
GEANFAMMER: A set of Perl programs developed for the analysis of most of the complete bacterial genomes announced since 1995. This can summarize the whole procedure of preparing statistically and biologically more relevant protein (sequence) duplication modules before any further analysis like structure and function assignment. This allows the user to easily analyze the duplication level and types of sequence families in any genome or database. A source code distribution is available.
[http://www.perl.com/CPAN-local/authors/Jong_ik/]
[http://cyrah.med.harvard.edu/Project/Geanfammer/]
GECO: An extensible, object-oriented framework for prototyping genetic algorithms written in Common Lisp. GECO makes extensive use of the Common Lisp Object System (CLOS) to implement its functionality. The abstractions provided by the classes have been chosen with the intent of being both easily understandable to anyone familiar with genetic algorithms and of providing algorithm developers with the capability of customizing all aspects of its operation. The source code for GECO is available and it is documented in a manual available in PostScript format.
[http://www.aic.nrl.navy.mil/galist/src/]
gEDA: A collection of software tools for easing electrical circuit design, simulation, prototyping, and production. The gEDA package currently (4/98) contains a schematic capture tool called gschem for drawing and laying out circuits using a computer. The features of this program include drawing graphics primitives and electrical elements, grouping such elements into components or parts, using the same interface to draw schematics and components, a component library with the basic symbols, drawing nets to interconnect components and other nets, visual indicators to show if a net is dangling or connected to another net, selection of multiple objects, and more.
Additional tools are to be included in the package including:

gnetlist, for netlist generatino and verification;

gplace, for board layout;

gpcb, for printed circuit board layout;

gsim, a design simulator; and

gfpga and gpld, for compiling designs into these devices.

A source code distribution of gEDA is available. It is being developed on a Linux Intel platform with compilation and use also requiring GTK. The documentation is still a bit sketchy.
[http://www.geda.seul.org/]
gEdit: A text editor created using the GTK library. The features include auto indent, printing, support for plug-ins, multiple documents, etc.
[http://gedit.pn.org/]
GEF: The Graph Editing Framework is an Open Source Java library for creating connected graph editors. The features of GEF include:

automatic redrawing at appropriate times to reflect changes;

multiple layers with each layer containing part of a diagram;

multiple views of the same diagram in multiple editors, with changes in one editor reflected in all others;

zooming and panning;

background layer grids for making structured diagrams;

loading and saving of diagrams;

a wide range of graphics primitives for building diagram elements;

representation of connected graphs consisting of nodes, ports and arcs;

a broom alignment tool for aligning parts of a diagram; and

limited cut and paste capabilities.

A source code distribution of this Open Source package is available. This is used as part of Argo/UML.
[http://www.ics.uci.edu/pub/arch/gef/]
GELDA: A Fortran 77 package for the numerical solution of linear differential-algebraic equations (DAEs) with variable coefficients of arbitrary index together with an initial condition. GELDA is based on the construction of a discretization scheme that first determines all the local invariants and then transforms the system into a strangeness-free DAE with the same solution set. The resulting system may still have nonuniqueness in the solution set or inconsistent initial values or inhomogeneities, but this information is now available to the user and can be treated in a least squares sense. If the DAE is found to be uniquely solvable, GELDA can compute a consistent initial value and then apply well-known integrations schemes for DAEs to obtain the solution. See Kunkel et al. (1997).
[http://www.tu-chemnitz.de/~mehrmann/gelda/]
GELLMU: Generalized Extensible LaTeX-Like MarkUp is a project to provide a markup language and a system design with provision for mathematics that is structured enough to admit automatic processing into many different formats for presentation. GELLMU is not itself LaTeX although its style of markup does resemble that of LaTeX. A GELLMU document contains content but no instructions for the presentation of that content. Separate translator programs are used to convert the document to each desired presentation format. GELLMU is a markup language under SGML, i.e. after a document is translated into a markup language falling formally under SGML it can be processed with any general purpose SGML tool.
A set of tools for creating and transforming GELLMU documents is currently (12/98) under development. These include:

gellmu.el, an Elisp program for converting GELLMU input into an SGML document from within Emacs;

gellmu.decl, an example SGML Declaration;

gellmu.dtd, an example SGML DTD needed by a stage two SGML parser (e.g. nsgmls);

catalog, an SGML catalog for the stage two processor;

htmlgart.pl, a codelet package for producing HTML; and

ltxgart.pl, a codelet package for producing LaTeX.

Source code version of all of these tools are available. The site contains much in the way of documentation.
[http://math.albany.edu:8000/math/pers/hammond/igl.html]
gema: The GEneral purpose MAcro processor is a general purose text processing utility based on the concept of pattern matching. It reads an input file, performs various specified transformations to the data, and copies it to an output file. It can be used to perform the sorts of replacement operations done by cpp, grep, sed, awk, etc., and can also be used as a macro processor. As a macro processor it is more general than cpp or m4 since it doesn't impose any particular syntax for what a macro call looks like. It can deal with patterns that span multiple lines and with nested constructs. It can also use multiple sets of rules to be used in different contexts. A source code distribution of gema is available. It is written in C and can be compiled on most UNIX flavors. It is documented in a user's manual and a man page, both of which are available in PostScript format.
[http://www.ugcs.caltech.edu/gema/]
GemMex: A graphical editor and program generator for the Montages language for specifying the formal semantics of domain-specific and general purpose programming languages. GemMex is a complex system assisting a designer with a number of activities related to a language life cycle from early design to routine programmer usage. It consists of several components including:

Gem, the Graphical Editor for Montages is a sophisticated graphical editor in which Montages can be entered and manipulated which also can produce output documentation;

Mex, the Montages Executable generator automatically generates correct and efficient implementations of the language; and

a generic animation and debugger tool for visualizing the static and dynamic behavior of a specified language at the symbolic level.

This was built using the Sather language and is also built on top of Aslan. A binary distribution is available for Linux Intel and some other platforms.
[http://www.first.gmd.de/~ma/gem/]
GemVt: The GNU emulator of a Virtual terminal is a terminal emulator for the X11 system. This is written using GTK.
[http://ring.htcn.ne.jp/pub/graphics/gimp/users/timj/gemvt/]
GENBLIS: GENetic optimization and Bootstrapping of LInear Structures is an evolutionary program that estimates structural equation models with latent variables. It does this by combining the global search strength of evolutionary algorithms with the capability of derivative-based programs to do rapid local hill climbing. It provides bootstrap confidence intervals for parameters and limits for the goodness-of-fit statistic. Structural equation models are used in various fields to specify and estimate stochastic models for linear relations in the presence of measurement errors. Binary versions of GENBLIS are available for several platforms including Linux Intel. See Bollen (1989).
[http://data.fas.harvard.edu/jsekhon/glisrel/]
GENEHUNTER: A gene map analysis package that allows the rapid extraction of complete multipoint inheritance information from pedigrees of moderate size. This result is then used to compute exact multipoint LOD scores and to perform non-parameteric linkage analysis. Calculations involving dozens of markers can be done quickly, even in pedigrees with inbreeding and marriage loops. The multipoint inheritance information allows the reconstruction of maximum likelihood haplotypes for all individuals in the pedigree as well as information content mapping which measures the fraction of the total inheritance information extracted from the marker data. A source code distribution of GENEHUNTER is available. It is written in C and can be compiled with GCC. See Kruglyak et al. (1996) and Kruglyak and Lander (1998).
[http://waldo.wi.mit.edu/ftp/distribution/software/genehunter/]
Generic-NQS: The Generic-Network Queueing System is a networked, UNIX-based queueing system which supports both batch and device requests. It provides several facilities including remote queueing, request routing, remote status, queue access controls, batch request resource quota limits, and remote output return. This was originally developed as part of an effort aimed at tying together a diverse assortment of UNIX macnines into a single useful computational complex for NASA. The features of Generic-NQS which distinguish it from related systems include:

support for the processor set features of symmetric multi-processing (SMP) platforms (e.g. SGI IRIX and Digital UNIX);

the dynamic scheduling of local queues wherein G-NQS completely reorders its queues each time the queue contents change (with users with excess jobs having their jobs migrated towards the bottom of the queue);

cluster-wide dynamic scheduling through the use of queue complexes; and

kernel-based resource limits via a System Abtraction Layer which ensures that the limits of each individual OS are fully supported.

The features of NQS include:

support for both batch and device requests; support for all of the resource quotas enforceable by the underlying UNIX kernel;

support for the remote queueing and routing of batch and device requests throughout the network of machines running NQS;

modularization of all of the request scheduling algorithms so the request schedulers can be easily modified;

support for queue access restrictions;

support for networked output return whereby the stdout and stderr files of any batch request can be returned to a remote machine;

allowance for the mapping of accounts across machine boundaries;

provision of a friendly mechanism for the modification of the NQS configuration on any particular machine;

support of status operations across the network so a user on one machine can obtain NQS information about other machines; and

provision of a design for the future implementation of file staging whereby several files or hierarchies can be staged in or out of a machine which eventually executes a batch request.

The source code is available and is easily compiled via a supplied configure script. Generic-NQS is supported on IBM AIX, Digital UNIX, Sequent Dynix/Ptx, Fujitsu UXP/M, HP-UX, SGI IRIX, Linux Intel, NCR UNIX, Sun Solaris and SunOS, DEC Ultrix, and Cray UNICOS platforms as well as on generic ports of BSD 4.3, POSIX.1, and System V Release 4 systems. The system is fully documented in an official manual set which, although not yet (5/97) complete, contains a System Adminstrator's Guide, a User's Guide, a Developer's Guide, and a Papers Set. It is also documented in a set of man pages.
[http://www.gnqs.org/]
GENESIS: The GENEtic Search Implementation System is a system for function optimization based on genetic search techniques, i.e. genetic algorithms (GAs). GAs are task independent optimizers and the user need only provide an evaluation function which returns a value when given a particular point in the search space. GENESIS provides a representation option which allows users to think about the genetic structure of their problem as vectors of real numbers rather than the usual bit strings, which makes application easier for many problems. Other features include: a display mode including an interactive user interface, the option to maximize or minimize the objective function, the choice of a rank-based or proportional selection algorithm, and an option to use a Gray code as a transparent lower level representation.
A source code distribution of GENESIS is available. It is written in ANSI C and can be compiled and used on any system capable of compiling such programs, including generic UNIX platforms. It is documented in an ASCII file included in the distribution.
[http://www.aic.nrl.navy.mil/galist/src/]
GENESIS: The GEneral NEural SImulation System is a general purpose simulation platform developed to support the simulation of neural systems ranging from complex models of single neurons to simulations of large networks made up of more abstract neuronal components. Most GENESIS applications involve realistic simulations of biological neural systems since other simulators are more suitable for more abstract networks like backpropagation and similar connectionist modeling. GENESIS and its graphical front-end XODUS are written in C and run on many UNIX platforms with X Windows, including Linux platforms. See Bower and Beeman (1994).
[http://www.bbb.caltech.edu/GENESIS/]

PGENESIS

A parallel version of the GENESIS neural net simulator that can run on multiple machines via the PVM library.
[http://www.psc.edu/Packages/PGENESIS/]
GENEsYs: An implementation of a genetic algorithm which extends the GENESIS package. The extensions include: the capability of invoking the GA via either command line options or the setup program; enhanced data collection features; the use of a function table from which the user chooses and object function when invoking the GA; several extensions of the basic GA, e.g. m-point crossover, uniform crossover, discrete and intermediate recombination, adaptive mutation rates, ( $\mu$ , $\lambda$ )-selection, and Boltzmann selection. The distribution compiles into several programs: ga, the basic genetic algorithm program; report, which automatically generates a report after a GA run; setup, an interactive setup procedure for a GA run; gapl, a plot procedure which uses Gnuplot; and gacols, which is used by gapl for data extraction.
A source code distribution of GENEsYs is available. It is written in ANSI C and can be compiled and used on most UNIX platforms. The system is documented in a user's manual contained in the distribution in LaTeX format.
[http://www.aic.nrl.navy.mil/galist/src/]
genetic algorithms: Genetic algorithms (GAs) are search algorithms based on natural selection and natural genetics. GAs work over a population of individuals which represent possible solutions to the problem being solved using a set of genetic operators, with the most common operators including selection, crossover, and mutation. The selection operator identifies the fittest individuals from the population using the value returned by an evaluation function whose form is problem dependent. The best individuals from each generation are combined between themselves using the crossover operator. The mutation operator is applied to some individuals to randomly change a part of their chromosome and introduce new genetic material to the population. GAs can be used to solve a wide range of problems with the most common application being function optimization problems. They work well on optimization problems which feature functions with many variables and which are multimodal, discontinous, or noisy, often when other methods fail or are inapplicable.
Packages which implement genetic algorithms include

ALGON,

DGENESIS,

GA Playground,

GAGS,

GAlib,

GAOT,

GECO,

GENESIS,

GENEsYs,

GP,

J/GAP,

PGA,

PGAPack,

REGAL, and

SUGAL.

Related software and further information can be found at ENCORE. See Goldberg (1989), Ladd (1995), Mitchell (1996b), Rawlins (1991), Whitley (1993), and Whitley (1995).
genetic programming: A branch of genetic algorithms (GAs) which differs from GAs in the representation of the solution. Genetic programming (GP) creates computer programs in the Lisp and Scheme languages as the solution, whereas GAs create a string of numbers representing the solution. GP solves problems by: generating an initial population of random compositions of the functions and terminals of the problem (i.e. computer programs); executing each program in the population and assigning it a fitness value according to how well it solves the problem; creating a new population of programs by copying the best existing programs and creating new programs by mutation and crossover; designating the best program that appears in any generation as the solution.
Packages that implement GPs are:

lil-gp, a GP tool written in C;

GPC++, a C+++ class library for applying GP techniques to a wide range of problems;

GPK, a C++ class library for GP tasks; and

GPsys, a GP system written in Java.

Related software and further information can be found at ENCORE. See Koza (1992) and Koza (1994).
[http://www.geneticprogramming.com/]
genocop: A series of programs implementing genetic optimization algorithms. The latest version (5) will optimize a function with linear constraints subject to a set of equalities, inequalities and domains. First it eliminates the equalities to reduce the number of variables. It then produces a set of equations which are all domain constraints, creates an initial population of variable vectors that satisfy the constraints, and repeats the process of evaluation, selection and recombination for the number of specified generations. The final output is a population of vectors with the values generated during the evaluation process. See ().
[http://www.coe.uncc.edu/~zbyszek/evol-systems.html]
genpak: A set of small utilities written in ANSI C to manipulate sequences in the classic UNIX manner. These utilities include:

gp_qs, quickly finds a sequence within a larger sequence;

gp_getseq, quickly retrieves a sequence fragment;

gp_gc, prints the GC content of a given sequence;

gp_tm, rints the Tm of a given sequence;

gp_matrix, looks for promoters in a set of sequence files using the Staden matrix method;

gp_randseq, prints random fragments from a sequence;

gp_seq2prot, converts a nucleotide sequence to a protein sequence;

gp_findorf, prints all ORFs contained in a sequence;

gp_cusage, prints the codon usage of a sequence; and

gp_slen, computes sequence length, mean and SE.

[http://www.bioinformatics.org/genpak/]
genpower: An enhanced version of the powerd UPS management package which adds additional functionality and a simpler means of daemon configuration. The genpowerd daemon will monitor the status of a serial line connected to a UPS and will initiate and halt system shutdowns based on the status of line and UPS power. The features include:

line power sensing to detect power failures and initiate delayed shutdowns or other actions;

detection of low battery power for initiating action;

detection of cable connections to detect errors; and

the ability to kill the UPS inverter to prevent the system from draining the UPS battery after it has shut down.

The package includes configurations for TrippLite and APC UPS units. A source code distribution is available.
[http://sunsite.unc.edu/pub/Linux/system/ups/]
Genscript: This package, also known as GNU enscript, is a free drop-in replacement for the Adobe enscript program. It will convert ASCII files to PostScript and either spools the generated PostScript to a specified printer or writes it to a file. Genscript can be easily extended to handle different output media and has many options which can be used to customize printous.
The features of Genscript include:

support for many different input encodings, e.g. ISO-8859/1 to ISO-8859-3 and ISO-8859-5, IBM-PC, 7 bit ASCII (and with some Scandinavian extensions), Macintosh, VMS Multinational, HP Roman-8, Adobe Standard Cyrillic Font KOI8 character set, the PostScript font's default encoding, and the PostScript interpreter's ISO Latin1 encoding;

support for AFM (Adobe Font Metrics) files;

FM files for the most common PostScript fonts included in the distribution;

PostScript font downloading;

choice of several output media, e.g. A3, A4, letter, legal, with new forms easily added;

support for user-defined fancy headers;

language sensitive highlighting;

N-up printing; and

support for special features such as inlined EPS images, changing body and color font on the fly, comments, etc.

The source code for Genscript is available and can be installed on most generic UNIX systems easily by use of the supplied configure file. The documentation is contained within an extensive man page.
[http://people.ssh.fi/mtr/genscript/]
Gentle: A programming language for compiler writers which provides a uniform framework to specify parsing, semantic analysis, transformation, and other compiler tasks. Gentle supports the description of compilers at a very high level and frees the writer from implementation details. It is designed around the concept of recursive definition and structural induction. Input and internal data structures are defined by listing alternatives for how to construct items from given constituents. Properties of these items are then described by giving rules for the possible alternatives. The rules recursively follow the structure of items by processing their constituents. The rule-based approach follows a principle of locality wherein complex interactions are avoided and a system can be understood by understanding small pieces in isolation. The leads to a data-oriented methodology where the structure of the data is mirrored by the structure of the algorithms.
A source code distribution of Gentle is available. It is written in ANSI C and can be compiled and used on most UNIX platforms. The documentation includes a primer, a language specification, a reference manual, and a library reference manual, all of which are available in PostScript format.
[http://www.first.gmd.de/gentle/]
gentoo: A file manager that uses a two-pane concept inspired by the Amiga DirectoryOpus program. The features include:

almost complete graphical configurability;

file typing and styling systems that allow the configuration of how different types of files are shown (i.e. with colors and icons) and what happens when you doubleclick on them;

nearly 100 original pixmap icons for various file types; and

internal support for most file operations.

Source code and RPM distributions are available. This is built using GTK.
[http://www.obsession.se/gentoo/]
GeNUAdmin: An automatic system administration tool for controlling the configuration and administration of UNIX workstations from a central management host. Relevant system data is kept in a central repository with the configuration of each machine extracted from this database. Extensive consistency checks are performed on the configuration data before calculating or updating configuration files. The GeNUAdmin system is written in Perl and is freely available upon signing and returning a license form.
[http://www.genua.de/software/ genuadmin_english.html]
GeNUBackup: A Perl package for performing backups on distributed filesystems on regular tape drives, sequential stackers, direct access tackers, and FTP servers. It maintains log files and information about what it did and when it did it. This is freely available upon signing and returning a license agreement.
[http://www.genua.de/software/genubackup.html]
GENZPACK: A set of routines and packages for the numerical computation of multiple integrals. These are for integrals that arise in a wide variety of applications including electromagnetics, chemistry, physics, and statistics. I've taken the liberty of calling the collectin GENZPACK after the author, Dr. Alan Genz. The packages include:

MVTPACK, for the computation of multivariate integrals;

RANRTH, for the computation of vector integrals over an infinite region with a Gaussian weight function;

POSTPACK, a collection of test log posterior densities as Fortran functions;

RNRTST, a test program for RNRTMX;

RNRTMX, for the computation of vector integrals over an infinite region;

BAYESPACK, a collection of routines for performing integrals that arise in Bayesian analysis;

BAYTST, a test routine for BAYESPACK;

ADBAYES, a subroutine for subregion adaptive integration of a vector function over a hyperrectangle;

HRMSYM, a subroutine for the computation of vector integrals over an infinite region with a Gaussian weight function;

MVNPACK, a collection of routines for the computation of multivariate normal integrals;

SCUSMP, a collection of routines for the numerical integration of a vector integral over a collection of simplices;

DCUHRE, a set of routines for the numerical computation of multiple integrals; and

MULTST, a multiple integration routine test package.

[http://www.math.wsu.edu/math/faculty/genz/homepage]
GEO-CGM: A Fortran 77 program to calculate corrected geomagnetic (CGM) coordinates and several other geomagnetic parameters for a geographically specified point in space, and vice versa. The underlying geomagnetic field model is the Definite/International Geomagnetic Reference Field (DGRF/IGRF) 1945-2000. CGM coordinates are tools for organizing geophysical phenomena controlled by the Earth's magnetic field like auroral boundaries, high latitude ionospheric processes, etc.
The user inputs the geographic or geomagnetic latitude and longitude, the altitude (up to 40,000 km), the geomagnetic field model Epoch (1945-2000), and a name for the point. The possible output parameters are the geomagnetic or geographic coordinates, the IGRF magnetic field components (H, D, Z), the dipole latitude and longitude, the geographic coordinates of the magnetically conjugated point, the geographic coordinates of the magnetic field line footprint, the apex of the magnetic field line, the Magnetic Local Time (MLT), and the angle between the geographic and CGM meridian at the given point. See Gustafsson et al. (1992).
[ftp://nssdc.gsfc.nasa.gov/pub/models/geomagnetic/geo_cgm/]
Geodetic Toolbox: A Matlab toolbox for performing various calculations related to geodetics. The programs include:

ell2utm, ellipsoidal (lat,long) to UTM (N,E) coordinates;

ell2yxz, ellipsoidal (lat,long) to Cartesian (x,y,z) coodinates;

sph2xyz, spherical (az,va,dist) to Cartesian (x,y,z) coordinates;

xyz2sph, cartesian (x,y,z) to spherical (az,va,dist) coordinates;

xyz2ell, cartesian (x,y,z) to ellipsoidal (lat,long,ht) coordinates;

xyz2ell2, xyz2ell with Bowring height formula;

xyz2ell3, xyz2ell using complete Bowring version;

refell, reference ellipsoid definition;

cct2clg, conventional terrestrial to local geodetic cov. matrix;

clg2cct, local geodetic to conventional terrestrial cov. matrix;

ct2lg, conventional terrestrial (ECEF) to local geodetic (NEU);

lg2ct, local geodetic (NEU) to conventional terrestrial (ECEF);

dg2lg, differences in Geodetic (lat,lon) to local geodetic (NEU);

lg2dg, local geodetic (NEU) to differences in geodetic (lat,lon);

direct, direct geodetic problem (X1,Y1,Z1 + Az,VA,Dist to X2,Y2,Z2);

inverse, inverse geodetic problem (X1,Y1,Z1 + X2,Y2,Z2 to Az,VA,Dist);

simil, similarity transformation (translation,rotation,scale change);

cal2jd, calendar date to Julian date;

doy2jd, year and day of year to Julian date;

gps2jd, GPS week and seconds of week to Julian date;

jd2cal, Julian date to calenar date;

jd2dow, Julian date to day of week;

jd2doy, Julian date to year and day of year;

jd2gps, JJulian date to GPS week and seconds of week;

jd2yr, Julian date to year and decimal year;

yr2jd, year and decimal year to Julian date;

dates, converts between different date formats;

errell2, computes error ellipse semi-axes and azimuth;

errell3, computes error ellipsoid semi-axes, azimuths, inclinations;

plterrel, plots error ellipse for covariance matrix;

pltnet, plots network of points with labels;

ToUTM, example of conversion from latitude,longitude to UTM;

DirInv, simple partial GUI script for direct and inverse problems;

DirProb, example of direct problem;

Dist3D, example to compute incremental 3D distances between points;

InvProb, example of inverse problem; and

PltNetEl, example plot of network error ellipses.

[ftp://ftp.geod.nrcan.gc.ca/pub/GSD/craymer/software/matlab/]
Geo-EAS: The Geostatistical Environmental Assessment Software package is a collection of interactive tools for performing 2-D geostatistical analyses of spatially distributed data. Features such as hierarchical menus, informative messages, full-screen data entry, parameter files, and graphical displays are used to provide a high degree of interactivity and an intimate view of results. The software is designed to make it easy for the novice to begin using geostatistical methods and to learn by doing as well ass to provide sufficient power and flexibility for the experienced user to solve real-world problems.
The programs that comprise Geo-EAS include:

Dataprep, which allows access to UNIX utilities and the manipulation, reading, and generation of Geo-EAS data files;

Trans, a program designed to create, delete or modify data file variables;

Stat1, an interactive program to compute basic univariate statistics and display histograms and probability plots for variables in a data set;

Scatter, a program to produce scatter plots of variable pairs in a data file;

Vario, a 2-D variogram analysis and modeling program;

Xvalid, a cross-validation program to estimate values at sampled locations in an area by kriging with the neighboring sample values;

Krige, a program that performs 2-D kriging (i.e. a weighted moving average method used to interpolate values from a sample data set onto a grid of points for contouring);

Corres, a program to perform correspondence analysis (i.e. a technique for displaying the rows and columns of a data matrix as points in dual low-dimensional vector spaces); and

Cokrig, a program which performs 3-D cokriging.

There is also the ability to view 3-D data sets using the XGobi software package.
The source code, written in Fortran 77, is available and the package is available in versions for standard UNIX and PC/MS-DOS environments. It can be used with either a command-line interface or a GUI (via the xgen program available with the GRASS distribution and also available at the Geo-EAS site). The separate installation of the aforementioned XGobi package is needed for the "spinning" of 3-D data sets. The documentation is contained within a 120+ page user's manual in PostScript format.
[ftp://math.arizona.edu/incoming/unix.geoeas/]
geoma: A C++ template class that implements geometric or Clifford algebras. A Clifford algebra is one generated by vectors from a quadratic space, and has been found useful in many physics, computer vision, and other applications. The main template class is GeometricAlgebra and implements the addition of a multivector and scalar, subtraction of a scalar from a multivector, and (left or right) multiplication of a multivector by a scalar. It also implements the negation, addition, subtraction, multiplication, coefficient access, grade involution, reversion, and conjugation of arbitrary elements.
[http://www.nklein.com/products/geoma/]
GEOMPACK: A mathematical software package, written in standard Fortran 77, for the generation of meshes using geometric algorithms. It contains routines for: 2-D convex decomposition and triangulation of polygonal regions; 2-D Delaunay triangulation; 3-D Delaunay and improved-quality triangulations; k-D Delaunay triangulation; and 3-D convex decomposition and triangulation of polyhedral regions. See Joe (1991).
[ftp://menaik.cs.ualberta.ca/pub/geompack/]
Geomview: An interactive program for viewing and manipulating geometric objects. It can be used as a standalone viewer for static objects or as a display engine for other programs which produce dynamically changing geometry. As a standalone viewer it can be used to see and manipulate objects described in a wide variety of file formats. As a display engine is can handle data coming from another program that is running simultaneously; as the other program changes the data the Geomview image dynamically reflects the changes. Such external programs are called external modules.
Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in SGI image file or Renderman RIB format, and adding or deleting objects is provided via direct mouse manipulation, control panels, and keyboard shortcuts. It supports several simple data types including polyhedra with shared vertices, quadrilaterals, rectangular meshes, vectors, and Bezier surface patches of arbitrary degree including rational patches. Object hierarchies can be constructed with lists of objects and instances of objects transformed by one or many 4x4 matrices, and arbitrary portions of changing hierarchies can be transmitted by creating named references. Geomview can also display 3-D graphics output from Mathematica and Maple.
Geomview is available as source code or in binary format for SGI IRIX, Sun Solaris and SunOS, Linux ELF (Intel), HP, IBM RS/6000, DEC Alpha, and NeXT platforms. The source code can be compiled on generic UNIX platforms with the X Window System, Motif, and an ANSI C compiler. The 140+ page manual is available in either HTML or PostScript format. The March 1996 issue of the Linux Journal has an article about Geomview.
[http://www.geom.umn.edu/software/download/geomview.html]

JGV

The Java GeomView package is a version of Geomview written entirely in Java. A source code distribution is available.
[http://www.geom.umn.edu/java/JGV/]

Orrery

A program that works in conjunction with Geomview to display and animate an accurate model of the solar system. It displays all of the planets, most of their moons, and a few comets, and shows them at a specified earth date and time. It animates the motions of the bodies at a specified rate either forwards or backwards in time. A source code distribution of Orrery is available. It will run on any system that has Geomview 1.6.1 or higher, although apparently an SGI with hardware texture mapping capability is needed to obtain texture-mapped planets at a reasonable refresh rate.
[http://www.geom.umn.edu/software/orrery/]

scatter2graph

A program that generates a surface from the values of a function sampled on an irregular grid. The output is in a form that can be viewed with Geomview. A source code distribution of this ANSI C code is available.
[http://www.geom.umn.edu/software/download/scatter2graph.html]

StageTools

A set of external modules for Geomview that provide a way to create animations in the form of MPEG movies, animated GIFs, or video tapes. This is done by writing a script which indicates how the objects should move within Geomview. StageTools consists of a set of modules, i.e.

StageManager, the main tool which lets you script movies, save them in files, preview htem, and record them in final form;

StageStills, which lets snapshots be taken of Geomview scenes;

CenterStage, which facilitates the creation of Geomview objects via mathematical formulas; and

StageHand, which allows the interactive control of Geomview using the high-level language of StageManager.

A source code distribution of StageTools is available. The package is written in Tcl/Tk and also requires ImageMagick, mpeg_play, and gifmerge for access to all of its capabilities.
[http://www.geom.umn.edu/software/StageTools/]
GEOPACK: A library of Fortran subroutines for magnetospheric modeling studies. These subroutines compute the geomagnetic field components at any point of space within the Earth's magnetosphere up to the Moon's orbit and trace the force lines starting at a given initial point. Given the universal time and day of year, these automatically perform all the necessary rotations of coordinate axes and take into account the tilt angle of the Earth's magnetic dipole axis.
The subroutines comprising GEOPACK are:

IGRF, which computes the three spherical components of the main (internal) magnetic field in the geographical coordinate system;

DIP, which computes the Cartesian solar-magnetospheric (GSM) components of the Earth's magnetic field corresponding to the first (dipole) term in the spherical harmonic expansion;

SUN, which computes the spherical angles of the Earth-Sun line in the geocentric inertial coordinate system and the Greenwich mean sidereal time;

SPHCAR, which computes spherical coordinates from Cartesian coordinates and vice-versa;

BSPCAR, the calculates the Cartesian components of a vector from the spherical components and coordinates;

RECALC, which computes the angles defining the geodipole orientation for a given UT moment as well as elements of matrices for transformations between the geographic (GEO), dipole geomagnetic (MAG), solar-magnetic (SM), solar-magnetospheric (GSM), and solar-ecliptical (GSE) geocentric coordinate systems;

GEOMAG, which transforms between the geographic and dipolar geomagnetic Cartesian coordinates;

GEIGEO, which transforms between geocentric equatorial inertial and geographical coordinates;

MAGSM, which transforms between the Cartesian dipolar magnetic and solar magnetic coordinates;

GSMGSE, which transforms between geocentric solar magnetospheric and geocentric solar ecliptical coordinates;

SMGSM, which transforms between solar magnetic and solar magnetospheric coordinates;

GEOGSM, which transforms between geographical Cartesian and solar magnetospheric coordinates;

RHAND, which computes the right-hand sides of the field line equations;

STEP, which makes one step along a force line of a magnetic field; and

TRACE, which computes the GSM coordinates of points lying on a geomagnetic field line.

See Tsyganenko (1990).
[http://www-spof.gsfc.nasa.gov/Modeling/request.html]
geostatistics: Related packages include:

Geo-EAS

GSLIB

Gstat

SGS

UNCERT
GeoTIFF: A TIFF-based interchange format for georeferenced raster imagery.
[http://home.earthlink.net/~ritter/geotiff/geotiff.html]
[http://www.remotesensing.org/geotiff/geotiff.html]
Geotouch: A three-dimensional Geographical Information System (GIS) mapping and data exploration tool for geology and geophysics. Both 2- and 3-D geographic objects are read from ASCII files and displayed in plan view in the main window. The full 3-D field can then be scrolled through in successive horizontal slices or arbitrary 2-D slices can be displayed. Several cross-sections can be viewed simultaneously along with a plan view. The displayed images are connected to the object database so parameter values or groups of them can be interactively displayed and/or stored. Geotouch also allows the image to be interactively spun about an arbitrary axis. Many features especially conducive to the viewing and manipulating of geophysical images are also included.
A binary versions of Geotouch for Sun platforms is available along with the source code. The source is written in ANSI C and is POSIX compliant which should ease porting to other machines. Compilation also requires the NetCDF libraries. A file detailing changes that need to be made on Linux platforms is available. The documentation is presently contained within the man pages and in a journal article, both of which are available in PostScript format.
[http://www.geology.yale.edu/~lees/Geotouch/]
Geotrans: An open source coordinate transformation tool whose capabilities include:

all data transformations specified in the NIMA WGS-84 technical report;

accurate coordinate transformations between 25 different coordinate systems, grids and projections;

height conversions between heights referenced to the WGS-84 ellipsoid and Mean Sea Level;

output coordinate accuracy reporting;

creation of user-specified datums and ellipsoids; and

coordinate file processing.

[http://www.remotesensing.org/download/NIMA.php3]
getpop: A POP3 client specifically designed for use on Linux systems connected to the Internet via temporary dialup. It can be installed to run at frequent intervals via cron and is fully compatible with most email systems currently in use, e.g. it can be processed by procmail. Getpop supports UIDL tags to assure the reliable delivery of messages without duplicates, and it can be set up to download mail from more than one server. A source code distribution is available.
[http://sunsite.unc.edu/pub/Linux/system/mail/pop/]
gettext: A GNU package which is part of the GNU Translation Project. It includes an integrated set of tools and documentation which provide a framework to help other GNU packages produce multi-lingual messages. The tools include a set of conventions about how programs should be written to support message catalogs, a directory and file naming organization for the message catalogs themselves, a runtime library which supports the retrieval of translated messages, and a few stand-alone programs to massage the sets of translatable strings or already translated strings in various ways.
A source code distribution of gettext is available. It is written in C and can be compiled and installed on a wide range of machines via the autoconf scripts supplied in the distribution. It is documnted in a user's guide available in Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
GFARIT/GFPLYS/GENIN: A set of Fortran programs for generating Niederreiter's low-discrepancy sequences. These are well-spaced sets of points for use in multidimensional integration and global optimization problems. This is TOMS algorithm 738 and is documented in Bratley et al. (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
GFax: A front-end FAX program that presents a pop-up FAX manager when printing to a FAX printer. GFax will work with any Linux program that can use lpr as a printer interface. It relies on underlying FAX transport software such as mgetty+sendfax to send FAXes. The features include:

a personal phone book;

user authentication;

personal settings; and

simple cover page support.

A source code distribution is available which requires Tcl/Tk 7.5 and 4.1 or newer, respectively.
[http://www.gmsys.com/gfax.html]
GFC: The Geographic Foundation Classes library is a light-weight class library for developing geographic information applications. The functionality of the modules therein includes:

space-time and attribute ADTs;

geometric, topological, graphical and cartographic algorithms; and

spatial indexing structures.

[http://www.remotesensing.org/download/]
GFIG: An interactive drawing package for creating flow charts, data structure diagrams, and the like. It is intended as a replacement for xfig, offering a more modern interface. This is not a vector or CAD drawing package. The source code distribution requires GTK for compilation and use.
[http://k332.feld.cvut.cz/~lemming/projects/GFIG.html]
GFit: A program for displaying, examining and manipulating pairs of X-Y data values. The functionality includes fitting model functions to measured data and calculating the Abel inversion of 2-D data sets. A source code distribution is available which requires the GTK toolkit for compilation.
[http://www.eudoxos.net/gtk/]
gFONT: A program that creates a GIF image for a given ASCII string by using an arbitrary TeX-available font. The font is converted from TeX's PK format to gFONT's GdF format and rendered into the resulting GIF image using its own library. This is intended for creating short typographical strings for inclusion on a Web page without having to invoke a huge program like Photoshop or use obscure HTML features.
A source code distribution of gFONT is available. It is written in C and Perl. It is documented in a man page.
[http://www.engelschall.com/sw/gfont/]
gforge: A program for creating fractal forgeries of landscapes and textures. It creates a landscape texture by a process known as random fractal forgery which begins with the preparation of an array of random data in the frequency domain. The size of the array is proportional to how realistic the pictures will look. A roughness parameter determines whether the resulting terrain is rolling hills or jagged mountains.
The gforge package directory also contains several useful ancillary programs: fft-n, a general purpose N-dimensional FFT routine (in C); hf-lab, a utility to generate and manipulate heightfields; orb-cyl, a program to make spherical or cylindrical triangle meshes, and sparkl01, a program to add sparkle or glint-type effects to an image. All the programs are available as source code.
[http://shell3.ba.best.com/~beale/gforge/]
gforth: A fast and portable GNU implementation of the ANSI Forth language. It works with the Emacs editor and offers such features as input completion and history and a powerful locals facility. It employs traditional implementation techniques, with the inner interpreter either indirect or direct threaded. The source code is available as well as binaries for Linux and OS/2 platforms. There is also the beginnings of a manual.
[http://www.complang.tuwien.ac.at/forth/gforth/]
GFS: The Global File System is a project to develop a serverless file system that fully exploits new interfaces like fibre channel that allow network attached storage. This allows all client computers to have full access to all storage devices on the network and makes access more efficient and reliable. GFS distributes the file system responsibilities across the processing nodes, storage across the devices, and file system resources across the entire storage pool. It caches data on the storage devices instead of the main memories of the machines. Consistency is established using a locking mechanism maintained by the storage device controllers to facilitate atomic read-modify-write operations.
GFS views storage as a Network Storage Pool (NSP) wherein a collection of network-attached storage devices are logically grouped to provide node machines with a unified storage space. The storage pools are not owned or controlled by any one machine but rather act as shared storage for all machines and devices on the network. The NSPs are divided into subpools, each of which takes on the attributes of the underlying hardware. Each GFS file system is divided into several Resource Groups (RG) designed to distribute file system resources across the entire storage subpool. These RGs are essentially mini-file systems with each group having an RG block, data bitmaps, dinode bitmaps, dinodes and data blocks. There is also a superblock containing information that cannot be distributed across the RGs including the number of nodes mounted on the file system, bitmaps to calculate unique identifiers for each node, the device on which the file system is mounted, and the file system block size. It also contains a static index of the RGs which describes the location of each group as well as their attributes and configuration.
Source code versions of GFS are available for Linux and IRIX platforms. Documentation includes several technical reports, presentations, and various other documents.
[http://www.globalfilesystem.org/]
gFTP: An FTP client for X11 with a Motif GUI. The features of gFTP include:

multithreading for simultaneous downloads;

file transfer queues for downloading multiple files;

an extensive connection manager for managing site lists;

resuming interrupted transfers;

associating icons with particular file extensions;

downloading entire directories and subdirectories;

resuming interrupted file transfers;

caching of remote directory listings;

local and remote chmod;

FTP and HTTP proxy server support;

viewing and editing local and remote files;

passive and non-passive file transfers;

full graphical configuration; and

no buffer overruns for secure transfers.

Source and static binary versions are available.
[http://gftp.seul.org/]
GGCL: The Generic Graph Component Library is a general purpose, generic C++ library for graph data structures and graph algorithms. GGCL provides basic generic graph algorithms, graph data structures, uniformed property access methods, and functor-like methods to extending functionalities of graph algorithms.
[http://www.lsc.nd.edu/research/ggcl/]
GGI: The goal of the Generic Graphics Interface project is to create a standard way for a program to access graphics capabilities available in its runtime environment. It also seeks to establish a standard architecture for graphics hardware device drivers and their interaction with the operating system, to offer a redesigned console system to support and coordinate multiple video cards and multiple input devices attached to a single machine, and to offer a set of graphics libraries to perform useful graphical tasks.
There are a three key components of the GGI project.

LibGGI is the core library, designed to be dynamic and display-independent. A program written with this will display to any target (e.g. a graphics device) available in the runtime environment, with targets being compiled as separate dynamically loaded (i.e. shared) libraries. Each target exports its abilities to replace LibGGI stub functions.

KGI, the Kernel Graphics Interface is a standard graphics driver API which is abstract and intended to be portable. A KGI driver is compiled as a loadable module which can be inserted into the kernel at any point, and is put there to address the instability and security risks caused by purely userspace graphics. If a graphics application crashes, the kernel is able to reset the video mode as a part of other cleanup tasks.

EvStacks, or Event Stacks, is a new console system for Linux (and eventually other systems) intended to provide a more flexible and dynamic system for managing virtual consoles, including support for multiple video cards and input devices. This is done by arranging the console system into a tree with the branches and leaves making up input devices and virtual terminals. Events are broadcast through the tree starting at the root of their immediate parent, and they can pass through accept/deny/modify filters called stacks.

There are also various libraries that extend the capabilities of LibGGI including:

LibGGI2D, containing advanced drawing functions including polygons, arcs, sprites, stretching bitmaps, etc.;

LibGGI3D, which provides functionality specific to 3-D graphics and is based on OpenGL;

LibGGU, a general graphics utilities library containing common command-line parsing, loading and saving images in various formats, and other miscellaneous functionality;

LibGFont, a genetic font library providing a simple and consistent API for glyph rendering on top of other font engines (e.g. FreeType);

LibGWT, a general windowing toolkit containing functions for managing the complex clipping and event delivery needed to support a simple windowing system;

LibGII, a general input interface which manages user input and allows event abstraction; and

SVGALIB Wrapper, for supporting legacy SVGALIB applications.

Source code distributions of GGI are currently (6/98) available although it is still in the beta stage of development. Various documentation can also be found at the site.
[http://www.ggi-project.org/]

ggv

A graphics viewer for GGI. The image formats handled internally include bitmaps, GIF, PCX, TIFF, Targa, Greymap, Pixmap, XBitmap and Amiga IFF/ILBM. An external program provides JPEG support.
[http://users.quicklink.net/~gith/]
[ftp://ftp.ggi-project.org/pub/ggi/programs/viewers/]
GGK: The Generic Graphics Kernel is a project to develop a generic 3D graphics kernel. Functionalities include basic parameter aggregates and related oeprators, elementary graphical data types (vector, matrices, colors, etc.), essential scene collections, basic graphical design patterns, basic topological classes, abstract and concrete rendering classes, pixel-based output devices, rendering-independent mathematical functions, basic interaction classes, utility classes, and more. Derived kernels to date are GX, an extended ray-tracing kernel, GT, an NFF compatible ray-tracing kernel based on GX, EGR MAF, a distributed multimedia application framework, and EGR TIGER, an interpretive OpenG environment including Motif-like GUI functionality and high-level OpenGL-based kernel for educational purposes. The source code is available as well as papers describing it. Part of it requires OpenGL libraries although apparently it will work with Mesa as a replacement. The TclTk toolkit is also needed for some parts.
[http://metallica.prakinf.tu-ilmenau.de/Generic/generic.htm]
Ghostscript: An interpreter for the PostScript language and a set of C procedures (the Ghostscript library) that implement the graphics capabilities that appear as primitive operations in the PostScript language. There are two versions of this package, i.e. Aladdin Ghostscript and GNU Ghostscript, the differences between which are restrictions on use (with the former being more restricted than the latter) and version numbers (with the latter lagging somewhat behind the former). As of this writing (1/98) the GNU version is 3.33 and the Aladdin version is 5.10. The Ghostview package must be used to view Ghostscript output on an X11 interface.
A wide range of file format conversions and special applications are possible using the available Ghostscript drivers and auxiliary programs. These include:

view(cmyk/GIF/JPEG/pbm/pcx) for displaying and printing graphics file formats (CMYK, GIF, JPEG, PBM, and PCX);

converting PostScript to raster graphics formats (e.g. TIFF, PBM, PCX, BMP, etc.);

enhanced rendering using anti-aliasing;

pswrite and psgray, for converting PostScript to PostScript raster graphics to allow the printing of PostScript Level 2 files on devices with PostScript Level 1 interpreters;

pswrite and epswrite, for converting some PostScript to PostScript vector graphics;

ps2epsi, for creating ASCII previews for EPSI files;

ps2ai, for converting to Adobe Illustrator format; displaying and printing PDF files;

pdf2ps, for converting PDF files to PostScript;

ps2pdf, for converting PostScript to PDF (i.e. distilling);

viewing PDF files with Ghostview;

ps2ascii and pstotext, for extracting text from PDF files;

gslp, for printing simple text files via lineprinter emulation;

ps2ascii and pstotext, for extracting text from PostScript and PDF files;

prfont, for printing character tables for a given PostScript font;

and more.
Source code distributions of both GNU and Aladdin Ghostscript are available. Both are configured such that they can be easily compiled and used on most UNIX platforms. Various documentation is available at the site.
[http://www.cs.wisc.edu/~ghost/index.html]
Ghostview: A full function X Window user interface for Ghostscript. It parses any known version of Adobe's Document Structuring Conventions, determines page size automatically from the Document Structuring Comments, creates scrollbars when necessary, determines page orientation automatically, allows zooming, and more. The source code is available and should install reasonably easily on a generic UNIX/X11 platform, e.g. Linux.
[http://www.cs.wisc.edu/~ghost/ghostview/index.html]
ghttpd: A fast and efficient HTTP server with CGI support. It has a small memory imprint but is capable of handling thousands of simultaneous connections. The source code is available under the GPL.
[http://www.gaztek.co.uk/ghttpd/]
GHX: GTK Hotline for X is a clone of a Mac program that combines FTP, IRC and News functionality in one program using a proprietary protocol. A source code distribution is available which requires GTK for compilation.
[http://ac2i.tzo.com/freesoft.html]
GIANT: The Graphical Interactive Analysis Network Toolkit is an analysis system for the consistent analysis of large, heterogeneous seismological data sets. It provides a GUI between a relational database and analysis tools (such as the related PITSA). More later as I decipher the terribly non-standard PostScript in which the manual is written.
[http://lbutler.geo.uni-potsdam.de/service.htm]
GIANT: A package for the solution of large scale, highly nonlinear systems using Global Inexact Affine-invariant Newton Techniques. GIANT uses a damped affine invariant Newton method combined with the iterative solution of the linear systems which arise. This is written in Fortran 77 and documented via comment statements within the source code. This is part of CodeLib.
[ftp://ftp.zib.de/pub/elib/codelib/]
[http://www.zib.de/SciSoft/ANT/giant.en.html]
Giant Java Tree: A public domain project with the primary goal of creating a giant Java source tree consisting entirely of Open Source. The packages currently (4/99) contained therein include those for:

a complete FTP client library;

implementing a CVS client/server protocol;

an ICEMail email client application;

a JDBC-based SQL client application;

support for UNIX tar archives;

a basic desktop framework application package;

basic GUI widgets;

a random text generator; and

a set of utility classes for parsing and generating HTML files.

[http://www.gjt.org/]
Gibraltar: A Debian-based router and firewall package bootable directly from CD-ROM. The functionality includes:

dynamic routing using BGP4, BGP-4+, RIPv1, RIPv2, RIPng, OSPFv2 and OSPFv3;

routing based on source address, incoming interface, type of service, source/destination port, protocol type, etc.;

multicast routing;

full NAT and masquerading support;

RSVP;

support for Ethernet, wireless, token ring, ARCnet, PPP, SLIP, PLIP, ISDN and ham radio network interfaces;

support for multiple interfaces;

advanced firewalling (stateful/non-stateful);

address configuration options including static, BOOTP, DHCP and dynamically via PPP;

usable as a DHCP server for configuring IPv4 clients; and

can configure IPv6 clients that use stateless autoconfiguration.

ISO images for the distribution are available.
[http://gibraltar.vianova.at/]
gIDE: A GTK-based IDE for C programming. The features include:

an editor with syntax highlighting and automatic indenting; and

integration of GNU C and GDB.

This is still (6/99) in the development stage.
[http://gide.pn.org/]
GIFLIB/libungif: A C-callable library of functions for reading, writing, and manipulating images in GIF format. GIFLIB also includes a toolkit of manipulation utilities with which you can crop, scale, flip, rotate, manipulate color tables, and more.
[http://prtr-13.ucsc.edu/~badger/software/libungif/]
[http://sunsite.unc.edu/pub/Linux/apps/graphics/suites/giflib/]
Gifmap: A package which supports making image collections available on the Web. It recurses through directory trees, building HTML pages, imagemap files, and client-side/server-side maps to allow the user to navigate through collections of thumbnail images (somewhat similar to xv's Visual Schnauzer) and select the image to view with a mouse click. It is highly configurable via either the command line or rc files, and it is optimized to use browser features like frames and client-side imagemaps.
Gifmap is written in Perl and compatible with versions 4 and 5. It also requires the use of the ImageMagick package. It should be usable on any UNIX system on which these programs are available.
[http://www.cyberramp.net/~bfriesen/gifmap/]
[ftp://ftp.wizards.dupont.com/pub/ImageMagick/gifmap]
GIFMerge: A program to merge single GIFs into GIF89a animations. Gifmerge uses the GIF89a extensions as well as the extensions supported by Netscape 2.0 with n-loops to allow a series of single GIFs to be combined into an animation file. See also WhirlGif.
[http://the-labs.com/GIFMerge/]
[http://www.tu-chemnitz.de/~sos/GIFMERGE/]
Gifsicle: A command-line tool for creating, editing, and getting information about GIF images and animations. Gifsicle can be used to create GIF animations as well as extract frames from them. It gives the user control over interlacing, comments, looping, transparency, and just about everything else. A source code distribution is available. It is written in C and highly portable.
[http://www.lcdf.org/~eddietwo/gifsicle/]
GigaBASE: An object-relational database management system that can handle databases up to a terabyte in size. This database system inherits most of the features of the related FastDB, but uses a page pool instead of direct memory mapping on virtual memory for data extraction. GigaBASE has both relational (i.e. a simple data structure and non-procedural query language) and object-oriented (direct object references and user-defined types and methods) features. It is primarily intended for applications requiring fast data retrieval by means of indices and direct object references, e.g. Web server database applications. A source code distribution is available for UNIX platforms. It has been tested on Solaris and Linux systems.
[http://www.ispras.ru/~knizhnik/gigabase.html]
GILDAS: The Grenoble Image and Line Data Analysis package is a collection of software oriented towards applications in radio astronomy. GILDAS consists of several major parts. A set of dedicated utilities that use the Sympathetic Interpreter of Commands (SIC) interface includes:

GreG, a general 1- and 2-D graphics program;

CLASS, a Continuum and Line Analysis Single-dish utility for single-dish data processing;

CFITS, a FITS to CLASS format translator;

ASTRO, a tool useful for preparing observing sessions; and

CLIC, for calibrating interferometer data.

A set of smaller programs for performing non-interactive time consuming processing are called Tasks.
A set of three monitor programs are:

VECTOR, a SIC-based program that can submit or run in parallel an GILDAS task;

GRAPHIC, a superset of GreG and VECTOR that also allows access to astronomical catalogs; and

OVERLAY, a 3-D version of GRAPHIC with which movies and the like can be created.

Also included is GFITS, a FITS translator for the exchange of data with the non-astronomical world.
Distributions of GILDAS are available for several platforms including Linux Intel. A large amount of documentation is available in both HTML and PostScript format.
[http://iram.fr/doc/gildas.html]
[ftp://iraux2.iram.fr/dist/soft/]
[ftp://ftp.tuc.nrao.edu/mirror/gildas/]
Gill: The Gnome illustration application is a drawing and graphics program planned to support all of the SVG.
[http://www.levien.com/svg/]
GIMP: The GNU Image Manipulation Program is, as you might have guessed, an image manipulation program. GIMP was created as an answer to what the developers call "the current lack of free (or at least reasonablly priced) image processing software for Linux and UNIX in general". Quite a bit of GIMP's functionality is invested in external modules called plug-ins which are called from GIMP to run as separate processes. As a result of this, many plug-ins are being developed by folks other than the original authors, an eventuality that is supported and, indeed, encouraged by those authors.
The functionality of GIMP includes:

support for 8, 15, 16 and 24 bit displays;

ordered and Floyd-Steinberg dithering for 8 bit displays;

RGB, grayscale and indexed color modes;

multiple views of the same image for complex tasks;

fast zooming and panning on images;

a full suite of selection tools (e.g. rectangle, ellipse, freehand, fuzzy, bezier, etc.);

many transform tools (e.g. rotation, scaling, shearing, flipping);

cropping, color picking, bucket-fill, blend and text tools;

paint tools;

a full set of brush masks and support for arbitrary brushes;

file support for JPEG, TIF, GIF, PNG and XPM formats; many effects filters (e.g. blur, edge detection, pixelize, etc.); and

various channel operations (add, composite, blend, etc.).

Among the many available GIMP plug-ins are:

PSD, which loads Adobe Photoshop files;

xmorph, which allows image morphing to be performed;

ps, which reads PostScript and PDF files and writes PostScript files;

emboss, which implements a standard emboss/bumpmap filter;

gimptcl, which adds Tcl as a scripting language;

Sobel edge-detect, which detects edges based on first derivatives;

Laplace edge-detect, which detects edges based on second derivatives;

diffraction, which generates diffraction patterns;

grid, which draws a grid on a picture;

faxg3, which reads G3 FAX files;

IfsCompose, which allows the creation of iterated function system fractals;

blinds, which transforms images such that they seem to be on window blinds;

xscanimage, which works with the SANE image scanning software;

TileIt, which tiles images into smaller versions of the original and fits them in the original image;

DeSpeckle, a despeckling package providing standard median, recursive median, adaptive, and recursive adaptive filters;

SnapShot, which takes a snapshot of a screen or a window;

Maze, which generates mazes using the depth-first search method;

AA, which saves images as ASCII art;

FFT, whicn calculates the FFT of an image;

GAG, which generates pictures using genetic algorithms;

Whirlpinch, which distorts and image by whirling and pinching;

HaruspeX, which provides a PostgreSQL connection;

MapSphere, which maps a picture to a sphere with lighting effects;

Warp, which iteratively distorts an image according to the gradient of a control matrix to give the effect of fluid motion or brush strokes;

Gerl, a hook into Perl 5 that allows Perl scripts to be written to perform manipulations;

Pagecurl, which implements the page curl effect;

MathMap, which allows the distorition and rendering of images based on mathematical expressions;

iwarp, for interactive image warping;

Gfig, for vector drawing;

PaperTile, which cuts an image and slides the pieces;

FlareFX, which simulates a lens-flare effect to simulate light shining into a camera lens;

and many more.
The GIMP source code, written in C, is available as well as binaries for Linux (ELF and a.out), FreeBSD (2.1 and 2.2), HP-UX, Solaris 2.4, SunOS 4.1.x and IRIX systems. The documentation thus far consists of a series of on-line tutorials for tasks ranging from the simple to the complex. A four part series on how to use GIMP can be found in the November 1997 through February 1998 issues of the Linux Journal.
[http://www.gimp.org/]
Gimp-Print: A GIMP plugin containing high quality printer drivers for Ghostscript and CUPS. The features include:

support for several printers including most EPSON Stylus Photo and Color printers, many of the HP DeskJet and LaserJet series printers, Canon BJC printers, and PostScript Level 1 and 2 printers;

support for the 6-color capabilities of some of the Stylus Photo printers;

computations performed on 16-bit rather than 8-bit lookup tables to eliminate stair-stepping effects in pale tones;

use of CMY mixtures in addition to black for the black component to reduce speckling effects;

hand tuning of the dithering code to improve smoothness; and

many additional output controls.

[http://gimp-print.sourceforge.net/]
GiNaC: GiNaC is Not a Computer algebra system is a package designed to allow the creation of integrated systems that embed symbolic manipulations together with other functionality, e.g. computation intensive numerical applications, GUIs, etc.). GiNaC doesn't attempt to provide extensive algebraic capabilities and a programming language but rather extends an existing language, i.e. C++ with a set of algebraic capabilities. It was originally developed as a replacement engine for xloops but has wider applications. The features and functionality include:

fast manipulation of large integers and rational via the CLN library;

efficient handling of multivariate polynomials and rational functions;

linear algebra support including symbolic matrices, vectors and equation solving;

very fast heuristic polynomial GCD;

a range of built-in functions, e.g. sin, cos, factorial, etc.;

symbolic differentiation and series expansion of all built-in functions;

severa forms of output including as optimized C++ for numerical postprocessing; and

memory efficiency and safety via the internal use of reference counting for all expressions.

[http://www.ginac.de/]
GINA++: The Generic INteractive Application for C++ is an object-oriented application framework that facilitates the development of applications having a GUI. It is written in C++ and uses OSF/Motif and the X Window system for the interface parts. GINA++ comes as a set of C++ classes plus a set of demo applications. The classes constitute an executable program that possesses the basic functionality and user interface components identical to all interactive graphical applications, but lacks any application specific behavior. Application specific behavior is implemented by adding new classes and member functions to the existing GINA++ classes. The classes are arranged into three layers: a basic layer consisting of a meta-object protocol, basic data structures, iterators, and wrapper classes for strings and primitive data types; a layer which provides an encapsulation of Motif; and a layer with application framework classes like documents, views, and commands.
A source code distribution of GINA++ is available. It is written in C++ and should with g++ (2.5.8 or later). Some demo applications may not compile with g++, e.g. those that use template classes. It is documented in a large user's manual available in PostScript format.
[ftp://ftp.gmd.de/gmd/]
GINGER: Ginger is an INteractive Graph EditoR is a powerful tool for interactive editing of various types of graphs. Features include interactively selecting, creating, editing and deleting nodes and edges; interactively positioning selected nodes; built-in layout algorithsm; exporting graphics in PostScript format; and much more. The GINGER implementation is based on Xt, Xaw, and Xlib and is being developed on Linux and Solaris platforms, so I assume it will compile and install on Linux boxes.
[http://www.cs.auc.dk/~normark/Ginger/ginger.html]
GIPSY: An interactive system for the reduction and display of astronomical data. GIPSY includes multi-tasking via a versatile user interface, advanced data structure capabilities, a powerful scripting language, and good display facilities. More later.
[http://www.astro.rug.nl/~gipsy/]
Giram: Giram Is Really A Modeller is a modelling program based on POV-Ray that aims to be a multi-purpose modeller. The features include:

the three views available in all 3-D modellers;

an exact view from the POV-Ray camera;

creating and manipulating various types of primitives including boxes, cones, cylinders, discs, height fields, planes, quadrics, spheres, superellipsoids, triangles, tori and constructive solid geometry generated objects;

a choice of wireframe, hiddenfaces and gouraud views;

use of OpenGL where available;

a CSG-tree window to observe and change the structure of scenes;

interactive translation, rotation and scaling;

zooming in and out;

loading/saving of POV scenes and AutoCAD DXF files;

editing of camera parameters;

a standard interface for plug-ins;

a POV-Ray frontend called povfront; and

GNOME compliance.

A source code distribution of Giram is available. It is written in C and uses GTK 1.2.
[http://www.minet.net/giram/]
GIRI: A Fortran 77 package implementing a method of inverse Rayleigh iteration for complex band matrices. This is TOMS algorithm 696 and is documented in Schrauf (1991).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
GIS (Geographic Information Systems): Software related to Geographic Information Systems includes:

GMT, a collection of UNIX tools for creating graphical images, with special emphasis on geophysical graphics

GRASS, a raster- and vector-based GIS, image processing, data management and spatial modeling system

[http://www.freegis.org/]
GiST: A C++ library for implementing a new kind of database indexing scheme called a Generalized Search Tree, which provides the functionality of the B-tree and all of its variations in one package. GiST is an extensible data structure which allows users to develop indices over any kind of data and supports any lookup over that data. The package unifies many popular search trees in one data structure (e.g. R-trees, B+-trees, hB-trees, TV-trees, Ch-Trees, etc.) which eliminates the need to build multiple search trees for handling diverse applications. GiST also has both data and query extensibility, the latter of which was lacking in previous tree structures. Query extensibility means that GiST can be programmed to support any query predicate via the implementation of four user-defined methods which define the behavior of keys in the search tree (although the the trickier the query the trickier the methods).
The GiST scheme is available either as libGiST, a C++ library, or as GiST for PG95, a patch for Postgres95. The library has been compiled on several UNIX platforms using gcc 2.7.2 and should be easily portable to others. The libGiST distribution includes documentation in HTML format, and more can be found in various technical reports in PostScript format at the home site.
[http://gist.CS.Berkeley.EDU/]
GIST: The Generic Information Server Toolkit is a toolkit for the development of interactive Web-based information servers. An information server is an interactive system composed of an information store and a means for clients to insert, remove, modify and visualize the contents of the store. GIST provides facilities for:

submission of information by members of a user community;

modification and deletion of information;

presentation of information;

searching and browsing;

user registration and user interface configuration;

user authentication and authorization;

automatic validation of user input; and

server configuration and definition of policy rules.

Source and binary distributions are available.
[http://gist.jrc.it/default/]
GIT: A set of interactive tools that contains an extensible file system browser, an ascii/hex file viewer, and process viewer/killer and some other related utilities and shell scripts. It can be used to increase the speed and efficiency of most daily tasks such as copying and moving files and directories, invoking editors, compressing and uncompressing files, creating and expanding archives, compiling programs, sending mail, etc. This is a GNU package and as such should compile and install fairly easily on a wide range of systems.
[http://www.gnu.ai.mit.edu/order/ftp.html]
GJ: A generic Java language extension that supports generic types. The extensions are implemented via translation into the unextended language. GJ increases expressiveness and safety, with code using this no longer buried under a plethora of casts and with the corresponding casts inserted by the translation guaranteed not to fail. It is designed to be fully backwards compatible with Java. The features of GJ include:

support for generic data types that require fewer casts and allow the compiler to catch more errors;

a superset of Java in which every Java source program is legal and the GJ compiler can be used as a Java compiler;

compilation of GJ into JVM code so GJ programs can run on any Java platform;

compatibility with existing libraries such that any Java library function can be called from GJ and (where sensible) GJ types can be assigned to existing libraries; and

efficient translation via erasure wherein no information about type parameters is maintained at run time.

A source code distribution is available.
[http://www.cs.bell-labs.com/who/wadler/pizza/gj/]
GKS: The Graphical Kernel System is a document produced by the International Standards Organization (ISO) which defines a common interface to interactive computer graphics for application programs. The full standard provides functional specifications for over 200 subroutines which perform graphics input and output in a device-independent manner, allowing programs to move freely between different graphics devices and host computers. GKS itself is not portable since individual implementations have to support different graphics devices on different computers and thus can vary substantially. GKS is also a kernel system in that it provides low-level graphics routines and not such high-level operations as creating contour plots or histograms. GKS functions are divided into eight classes: control functions, output attributes, output primitives, segment functions, transformations, input functions, metafile functions, and inquiry functions.
GKS is defined to have different levels such that particular applications can choose a package with appropriate capabilities. There are three levels for output (0,1,2) and for input (a, b, c), with the higher levels including the functionality of lower levels. There is also an ANSI-defined level m which sits below output level 0. A 2-D version of GKS was adopted in 1985, and a 3-D superset was defined and adopted in 1988. There are standard Fortran bindings to both versions. A freely available implementation of GKS is XGKS.
GLADE: The GNAT Library for Ada Distributed Execution is an implementation of the Distributed Systems Annex for the GNAT Ada compiler. It is a complete environment for developing distributed applications which includes a complete PCS (Partition Communication System), a simple partition description language and tool (gnatdist, and utilities to build and start distributed applications. An Ada95 distributed application consists of a number of partitions which can be executed concurrently on the same machine or on a network of machines. A partition is a set of compilation units which are linked together to produce an executable binary, with a distributed program consisting of two or more communicating partitions.
A source code distribution of GLADE is available. It is known to compile on Sun Solaris and SunOS and Linux Intel platforms. A user's manual is included in the distribution.
[http://www.gnat.com/]
[http://www.act-europe.fr/glade.html]
Glasgow Haskell Compiler: A compiler for the Haskell language. GHC is a fully featured implementation of Haskell with a number of useful extensions. It provides an extensible, monadic I/O system which fully supports the Haskell 1.4 specifications and also includes a POSIX system library which provides access to operating system facilities, e.g. a UNIX shell can be written in GHC. GHC provides the ability to call arbitrary in-line C language code using the I/O monad to retain referential transparency. The Haggis GUI toolkit is used to provide a graphical interface. GHC is written in Haskell and generates C as its target code.
The features and functionality of GHC include:

extensive optimization for performance comparable to other non-strict languages;

time and heap profiling;

a foreign function interface allowing GHC programs to call and be called by external programs, libraries or components;

type system extensions including multi-parameter type classes, explicit universal and existential qualification, and scoped type variables;

fully fledged unboxed data types for performance enhancements;

a set of extensions called Concurrent Haskell that allow the development of explicitly concurrent applications;

securely encapsulated mutable variables and incrementally-updatable arrays;

parallel execution support based on a distributed-memory store model which currently sits on top of PVM;

a simulator called GranSim for simulating parallel execution on a uniprocessor;

weak pointers and finalization to give control over the garbage collection of specified objects;

an exception library allowing exceptions to be raised in arbitrary code and caught in the I/O monad;

stable names, i.e. a concept that provides aliases for given objects that can be hashed or compared against others;

generational garbage collection; and

an extensive set of libraries including those for networking, a POSIX interface, exceptions, bitwise operations, dynamic types, readline, regular expressions, pretty printing and weak pointers.

A source code distribution of GHC is available as are binary packages for several platforms including Linux Intel. The documentation includes a user's guide, an installation guide, and several technical reports, all available in PostScript format.
[http://www.haskell.org/ghc/]

Happy

A parser generator system for Haskell similar to yacc for C. Happy takes a file containing an annotated BNF specification of a grammar and produces a Haskell module containing a parser for the grammar. Binary and source distributions are available, with the latter requiring GHC for compilation.
[http://www.dcs.gla.ac.uk/fp/software/happy/]

HaskellDirect

An IDL compiler for Haskell that facilitates interacting with and reusing external code. The functionality of a programming interface is specified in a framework independent of any programming language. This is converted into a set of method stubs by the HaskellDirect IDL compiler which can be used to:

call upon external functions from within Haskell;

let external code call upon Haskell functions;

call COM (a microshaft thingie) methods from Haskell; and

create COM method wrappers.

The IDL compiler understands both the OSF DCE and OMG IIOP/CORBA dialects of IDL. A source code distribution is available which requires GHC for compilation.
[http://www.dcs.gla.ac.uk/fp/software/hdirect/]
GLE: A high quality graphics package for scientists. It combines a user friendly interface with a full range of facilities for producing publication quality graphs, diagrams, posters and slides, and allows the user to modify every feature down to the smallest details using a large set of graphics primitives.
The graphics primitives are combined into graph modules, i.e. collections of commands that specify various features of the graph, e.g. annotations, tic marks, legends, line widths, axis labels, as well as what kind of graph to draw and how and where to read the data. The graphs can be created in black and white and in color. There are also utilities for fitting equations to experimental data and general data manipulation. Quasi 3-D surface plots can be made using a wire frame with hidden line removal. Output devices supported include VT100, 125 and 250, TEK4010, X Windows, PostScript, HPGL, EPSON, and HP Deskjet. Several examples are included with the package that can be used as templates.
The source code for GLE is available as well as binaries for DECstation, SUN, VMS, PC, OS2, and Linux platforms. Documentation is supplied in a 150+ page combination tutorial and user's manual in PostScript format which includes many examples.
[http://tbone.biol.sc.edu/~dean/glelist/]
[http://sunsite.unc.edu/pub/Linux/science/visualization/]
GLEX: A collection of routines for drawing sweeps and extrusions, i.e. a 2D contour (polyline) that is swept or extruded along a 3D path (polyline). An example would be sweeping a circle along a straight line to generate a cylinder. Other extruded surfaces include surfaces of revolution, sweeps, tubes, polycones, polycylinders and helicoids. The extrusions can be texture mapped in a variety of ways. The library itself generates 3D triangle coordinates, lighting normal vectors and texture coordinates as output, with GL or OpenGL APIs performing the actual rendering. The freely available OpenGL-like Mesa library is compatible with the GLE Extrusion Library. The library comes with several demos that require the GLUT windowing and utility library to be installed. The documentation is in hypertext format and comes with the package.
[ftp://tsx-11.mit.edu/pub/linux/sources/libs/]
GLI: The Graphics Language Interpreter is a complete graphics system offering an environment for plotting complex data sets and displaying images. It combines powerful interfaces, flexible graphics utilities, and an extensive set of programming tools to provide a complete solution for data analysis and scientific visualization.
The components of the GLI system are:

GLI, a command line interpreter that accepts simple statements from the GLI, GUS and GKS command languages which allow data to be read, manipulated and plotted by sophisticated 2- and 3-D plotting utilities;

GLI/TCL, which provides full support for all Tcl/Tk comands and widgets;

GLI/SIMPLEPLOT, which provides a command-driven environment for signal processing;

GLI/SIGHT, the Simple Interactive Graphics Handling Tool is a high-level graphics editor with a point-and-click interface for the creation, editing and publishing of 2-D graphs and freehand drawings;

GLI/IMAGE, a complete system for processing and displaying color and grayscale images based on the PBM format provided as a GUI point-and-click interface;

GLI/GUS, the Graphics Utility System offers many high-level graphics utilities and data handling commands, e.g. 2- and 3-D line graphs, scatter diagrams, bar and pie charts, contours, histograms, 3-D surfaces, data filters, linear and logarithmic transformations, and automatic text generation;

GLI/GKS, an implementation of GKS level 0a with minimal segment functionality which supports most popular graphics devices including X displays and PostScript; and

GLI/CGMVIEW, which displays CGM files generated on any computer system and can also print CGM files to any device supported by GLI/GKS.

A source code distribution of GLI is available which is said to work on several platforms including Linux Intel. A manual is available in PostScript format, although I think it is written in German. More later as I attempt to compile and use the thing (12/98).
[http://iff001.iff.kfa-juelich.de/gli/]
[ftp://iffftp.iff.kfa-juelich.de/pub/gli/]
glibc/GLIBC: See the GNU C Library.
GlimpseGate: A Glimpse gateway for the Web that gives users the full power of Glimpse for indexing and searching their data for the Web. The features include context searching of HTML documents, i.e. users get paragraphs that contain the search strings instead of lines or abstracts, and a powerful configuration facility that allows almost all aspects of the search form and result output to be modified. GlimpseGate is designed to support many separate indexes on a Web server. Installation and use requires Perl 5 and the CGI-modules and libwww-perl that can be found at any CPAN site.
[http://sunsite.bilkent.edu.tr/pub/infosystems/GlimpseGate/glimpsegate.html]
Glish: An interpreted language for building distributed systems from modular, event-oriented programs written in conventional languages such as C, C++ or Fortran. Glish is called a software bus in that individual programs are wholly modular with no knowledge of other programs or data types, with the bus providing a uniform way for programs to communicate without knowing about one another in a manner analogous to a hardware bus. The Glish software bus consists of: a C++ class library that programs (Glish clients) link with so they can generate and receive events and manipulate structured data; the Glish sequencing image language (analogous to Perl but different in flavor); and an interpreter process for executing Glish scripts and acting as a central clearinghouse for forwarding events between processes.
The Glish language is implemented as an interpreter written in C++. The documentation is contained within a couple of papers and a user's manual, both available in PostScript format. It was originally written for tasks within the Superconducting Supercollider Project (SSC), but when that fell through it was picked up by the AIPS++ Project at NRAO. It is apparently going through considerable further development there.
[http://www.atnf.csiro.au/computing/software/aips++/docs/glish/glish.html]
GLOBAL: A common source code tag system for C and YACC with which you can locate the specified function in C source files and easily move there. It is useful for hacking large projects containing many subdirectories and supports several environments including shell commmand line, the vi editor, Web browsers, and Emacs. A source code distribution of GLOBAL is available. This has been used to create browsable kernel source hierarchies for several freely available operating systems.
[http://www.tamacom.com/global/]
Global Array: A package that provides an efficient and portable shared-memory programming interface for distributed memory computers. Each process can asynchronously access logical blocks of physically distributed matrices without the need for explicit cooperation by other processes. This was designed to complement rather than replace the message passing memory model, and as such both the shared memory and message passing techniques can be used in the same program. GA is configurable to run with either the MPI message passing library or the TCGMSG portable message passing libraries.
The Global Array distribution contains:

Global Array, a portable Non-Uniform Memory Access (NUMA) shared-memory programming environment for distributed and shared memory computers;

TCGMSG, a simple and efficient message passing library;

TCGMSG-MPI, a TCGMSG library implementation on top of MPI and in some cases architecture-specific resources; and

MA, a dynamic memory allocator/manager for Fortran and C programs.

The source code for the GA distribution, written in Fortran and C, is available. The supported machines are Sun SunOS and Solaris, SGI, DEC Alpha, IBM workstations, KSR, IBM SP1 and SP2, Cray T3D and T3E, Convex SPP, IPSC, and Linux Intel. The GA, MA, and TCGMSG libraries can be built separately or together along with some sample programs. Documentation is contained within several technical reports in PostScript format as well as in an online manual in HTML format. See Nieplocha et al. (1996).
[http://www.emsl.pnl.gov:2080/docs/global/ga.html]
[http://www.hensa.ac.uk/parallel/libraries/memory/ global-array/index.html]
global optimization: Global optimization involves finding the best set of parameters for optimizing an objective function.
[http://www.cs.sandia.gov/opt/survey/]
[http://solon.cma.univie.ac.at/~neum/glopt.html]
GlobSol: The Global Solutions software is a self-contained Fortran 90 package that finds all rigorously verified solutions to constrained and unconstrained global optimization problems. It also finds all rigorously verified solutions to algebraic systems of equations. It contains utility routines for interval and point evaluation of objectives, gradients, Hessians, constraints, etc. at specified points, for iterating interval Newton methods, for finding approximate feasible points, etc.
The features of GlobSol include:

self-contained interval arithmetic based on INTLIB and INTERVAL_ARITHMETIC;

automatic differentiation based on operator overloading; and

an advanced combination of techniques including constraint propagation, an innovative method of finding approximate feasible points, epsilon inflation in verification, set complementation techniques to avoid large clusters of boxes, and a careful consideration of stopping criteria and tolerance.

[http://www.mscs.mu.edu/~globsol/]
Globus: A project to develop basic software infrastructure for computations integrating geographically-distributed computational and information resources. Globus is developing fundamental technology needed to build computational grids, i.e. execution environments that enable an application to integrate geographically-distributed instruments, displays and computational and information resources. The project is organized around four main thrusts:

Research, studying basic problems in areas such as resource management, security and algorithms;

Tools, building robust research prototype software that can run on a wide range of important platforms, i.e. the Globus Toolkit;

Testbeds, building and deploying large-scale testbeds, e.g. the GUSTO (Globus Ubiquitous Supercomputing Testbed); and

Applications, developing large-scale, grid-enabled applications in collaboration with scientists in various areas.

The tools and services needed to develop a computational grid infrastructure are contained within an integrated set of basic grid services called the Globus Toolkit whose components involve:

Resource Management

GRAM (Globus Resource Allocation Manager), which provides a uniform interface to a range of local resource management tools including LSP, NQE and LoadLeveler;

DUROC (Dynamically-Updated Request Online Coallocator), which implements allocation operations across multiple resource managers;

RSL (Resource Specification Language), which is used to pass application requirements to the underlying system;

Security

GSI (Globus Security Structure), which uses public key technology and X.09 certificates to provide single, sign-on, authenticated resource allocation and process-to-process authentication;

Information Infrastructure

MDS (Metacomputing Directory Service), which provides a distributed network-enabled infrastructure for publishing and obtaining information about components of the grid;

Communication

Nexus, a communication library providing unicast and multicast message delivery services;

Fault Tolerance

HBM (Heartbeat Monitor), which provides the ability to detect the failure of specific machines and processes and to build application-specific fault recovery mechanisms;

Nexus Fault Detection

Remote Data Access

GASS (Global Access to Secondary Storage), which allows an application to specify a remote file by specifying a URL and which supports read, write and append modes;

RIO (Remote I/O for Metasystems), which provides basic mechanisms for tools and applications that require high-performance access to data located in remote, parallel filesystems;

GEM (Globus Exectutable Management)

Various other tools that simplify the use of the Globus system include:

Java-based tools for browsing and monitoring information as well as for steering applications including:

Heartbeat Monitor, for observing the status of resources;

Network Monitor, for observing the status of the networks monitored with globperf;

MDS/LDAP Editor;

GRAM Flow Scheduler, for scheduling many cooperating jobs;

GECCO (Globus Environment Control Component), for allowing the interactive specification of GRAM jobs;

HM (History Manager), for recording and displaying history data;

GRS (Graphical Resource Selector), for selecting resources and scheduling jobs for distributions; and

Visual Tools, various tools for visualizing data and performance results.

Globus Activation API, for module activation (initialization) and deactivation (shutdown);

NCL (Nexus Component Library), providing primitive data conversion routines for implementing ``reader makes right'' communication libraries;

globus_utp, which implements timers for monitoring programs; and

globus_libc, which provides a thread-safe, portable interface to common libc functionality such as I/O, host resolution, etc.

A source code distribution of the Globus Toolkit software is available. It has been tested on several platforms including Linux RedHat 5.1 with libc version 2.07. The SSLeay version of SSL is needed for compilation and use. Large amounts of documentation are available in hypertext format at the site.
[http://www.globus.org/]
gloe: A Motif-based text editor. It is available as source code.
[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]
GlossTeX: A tool for the preparation of glossaries in the LaTeX document preparation system. A GlossTeX glossary is created by first preparing one or more glossary definition files which serve as databases containing descriptions of terms. These terms are identified through labels included in the text of the document. The program ascertains which entries in the databases have been used in the text and creates a formatted glossary for the text.
The GlossTeX program is written in ANSI C and can be used with LaTeX. It is documented in a brief user's manual in, what else, L^ATEX format.
[http://tug2.cs.umb.edu/ctan/tex-archive/support/glosstex/]
Glove: A tool for data acquisition, manipulation, and analysis. It was developed to fill a need for a generic plotting tool, an interface to data acquisition systems, sophisticated and correct statistical analysis, and the ability to easily and intuitively manipulate data. The features of Glove include:

a spreadsheet-like interface to data with in-cell data editing

powerful and flexible data transformations

arbitrary transformations, data import/export, and data acquisition via an extensible module system;

2-D plotting including an arbitrary number of curves, error bars on both axes, mouse-driven zoom, linear and log plotting on both axes, dual cursors on both axes, and function plotting; and

statistical analysis including correct linear fitting for data with errors in both variables, built-in quadratic and exponential fitting, arbitrary fitting via extensible modules, and residual plots.

Several more features are currently (6/98) under development. A binary distribution of Glove is available. It was creating using the JX toolkit.
[http://www.pma.caltech.edu/~glenn/glove/glove.html]
GLOW: A cross-platform object-oriented framework for building applications using OpenGL or similar APIs such as Mesa. The features of GLOW include:

an object-oriented C++ wrapper for GLUT;

various extensions to GLUT interfaces;

a powerful and extensible widget system;

a large widget library; and

source code compatibility across platforms.

The GLUT extensions include:

a component hierarchy for organizing and reusing drawable objects;

recursive activation and deactivation of components;

simulation of modal and non-resizable windows;

utility components including a 3-D manipulator;

additional menu manipulation capabilities including inserting and marking items; and

automatic computation of additional state including font metrics, local window positions, and menu status.

The features of the extensible widget system include:

widgets that may appear in any number of windows and subwindows;

a high-level API for creating widgets with a single line of code;

a low-level API allowing precise control of widget placement and options;

predefined message and text entry windows;

hierarchical arrangement of widgets using panels and other containers;

reporting widget events via virtual methods or receiver objects;

widgets that appear and behave the same across platforms; and

writing and integrating custom widgets into the system.

[http://www.ugcs.caltech.edu/~dazuma/glow/]
GLP: A C++ class library that uses the feedback mechanism in the OpenGL library to generate PostScript output from OpenGL files. A source code distribution is available.
[http://www.easysw.com/~mike/opengl/index.html]
GLSNET: A regional hydrologic regression and network analysis program that uses generalized least squares. GLSNET uses an analysis of residuals technique to estimate a regional regression equation to predict flow characteristics at ungauged sites. The analysis assigns different weights to observed flow characteristics with the weights based on record length, cross-correlation with flow characteristics at other sites, and an assumed model error structure. The problem of identifying sites from which to collect future streamflow data is formulated as a mathematical program using regional information and is subject to budget constraints. An approximate solution is obtained using a step-backward technique that identifies gauging station sites, existing or new, to discontinue or to not start data collection, respectively, if the budget is exceeded. This allows the design of a nearly optimal streamflow data network for collecting regional information.
A source code distribution of GLSNET for UNIX platforms is available. The primary documentation is contained within Tasker and Stedinger (1989). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/glsnet.html]
[http://www.geogr.uni-jena.de/software/glsnet.html]
gltt: A library that allows TrueType fonts to be accessed from any OpenGL. It supports bitmapped and anti-aliased font drawing as well as vectorized and polygonized drawing. Gltt is written in C++. It requires an OpenGL implementation such as Mesa and will work with the FreeType TrueType library.
[http://home.worldnet.fr/~rehel/gltt/gltt.html]
GLU: The Granular LUcid toolkit is a high-level system for granular data-parallel programming in which parallel applications are described as succinct implicitly parallel intensional compositions using sequential imperative functions. It is based on a hybrid language comprising an intentional language (Lucid) for specifying the parallel structure of the application and an imperative language (C) for specifying the various application functions. GLU has be designed for ease of use, architecture independence, support for existing sequentialcode, and efficiency across multiple architectures.
The toolkit consists of a parallel program generator, a parallel program compiler, and tools for launching GLU executables and analyzing their performance. The program generator creates, given a graph description describing data dependencies and a list of external functions that are used, generator and worker programs. The former is responsible for unraveling parallelism in the application graph description while executing external functions on multiple workers as well as coordinating data movement between workers, while the latter is responsible for retrieving the names of data functions and their argument data from the former, executing the functions, and returning the result. This generation stage creates C code from the GLU program, which consists of a Lucid part and a C part.
The compiler creates executables by compiling the generator and worker source code files along with the C part of the GLU program and appropriate runtime libraries. The runtime libraries contain all of the architecture-dependent features of each supported platform. Interaction between processes is defined in terms of a high-level asynchronous remote procedure call interface that is independent of particular communication and synchronization mechanisms. Several protocols for transporting information between processes are supported, including TCP/IP, PVM, CMMD, MPI and ATM, and both distributed- and shared-memory interactions are supported. Debugging is supported on both functional and performance levels.
The GLU system is available in binary form for OSF1, HPUX, FreeBSD, Linux, IRIX5, AIX, and SunOS4 (and 5) systems. The documentation consists of a 70+ page programmer's guide and several technical reports, all available in PostScript format.
[http://www.csl.sri.com/GLU.html]
GLUI: A GLUT-based C++ user interface library which relies on GLUT to handle of system dependent issues, i.e. it can be used anywhere that GLUT can be used. The features of GLUI include:

complete integration with GLUT

creation of interface windows with a single line of code;

support for multiple user interface windows;

a variety of standard controls/widgets such as buttons, radio buttons, editable text boxes, spinners, static text fields, and panels for grouping controls;

controls that can generate callbacks when their values change;

live variables that can be linked to controls and be automatically updated when the value of the control changes;

automatic synchronization of controls to reflect changes in live variables;

triggering GLUT redisplay events when control values change;

automatic layout and sizing of controls; and

grouping of controls into columns.

A source code distribution is available as is a manual in PDF format.
[http://www.cs.unc.edu/~rademach/glui/]
GLUnix: The Global Layer Unix package in an operating system built on top of a traditional UNIX operating system to support networks of workstations (NOW). The GLUnix OS supports gang scheduling of parallel programs, identification of idle network resources, allows for process migration to support dynamic load balancing, and provides support for fast interprocess communication for both the OS and user-level applications. It implements most of a single system image, providing a cluster-wide pid for each GLUnix process, enabling the status of jobs to be queried from any node, and allowing users to signal jobs from any node in the cluster. Existing application binaries can be run unmodified and batch jobs can be submitted via a batch system which regulates the system load.
The GLUnix commands available to the end user include:

glubatch, a batch job submission system for submitting and querying jobs;

gluenv, for displaying GLUnix-related environment variables;

glukill, for sending signals to jobs;

glumake, a paralle version of gmake;

glupart, a tool for managing the partitioning and naming of a GLUnix cluster;

glups, for querying jobs currently running;

gluptime, for finding out how long GLUnix has been running and how many jobs it has executed;

glurun, for running sequential and parallel jobs;

glush, a modified tcsh which automatically executes command-line programs on remote nodes; and

glustat, for querying how many machines are on the cluster and various other information about them.

The is also a GLUnix library called Glib which provides access to GLUnix facilities and with which the above utilities are written.
A source code version of GLUnix 1.0a is currently (6/98) available. The main source code is written in C++ and the accompanying utilities in both C and Perl. It has been compiled and tested using GCC on Sun Solaris platforms, so it might compile fairly easily on Linux Intel platforms. A tutorial is available as are man pages for each of the utilities.
[http://now.cs.berkeley.edu/Glunix/glunix.html]
GLUT: The OpenGL Utility Toolkit is a programming interface with ANSI C and Fortran bindings for writing window system independent OpenGL programs. It was created because of the lack of a window system interface for OpenGL, a decision that allowed it to be retargeted to a wide range of platforms. The GLUT toolkit supports:

multiple windows for OpenGL rendering,

callback driven event processing,

sophisticated input devices,

a simple, pop-up menu facility,

utility routines to generate various solid and wire frame objects,

support for bitmap and and stroke fonts, and

miscellaneous window management functions including managing overlays.

The GLUT API has been made as independent of window systems as is reasonably possible. As such it does not return any native window system handles, pointers or other data structures. The routines are organized into several sub-APIs according to functionality:

initialization routines to control command line processing, window system initialization, and initial window creation state;

a beginning event processing routine that enters the GLUT event processing loop, continuously performing callbacks when necessary;

routines to create and control windows;

routines to establish and manage overlays for windows;

routines to create and control pop-up menus;

routines to register callbacks;

routines for the manipulation of color index colormaps;

routines for retrieving state from GLUT;

routines for rendering stroke and bitmap fonts; and

routines for rendering 3-D geometric objects.

GLUT is available in an ANSI C version for X11 as well as in versions for Windows and OS/2. It can be used with the Mesa GL clone.
[ftp://sgigate.sgi.com/pub/opengl/xjournal/GLUT/]
GLX: A package that provides the code needed to connect OpenGL and X11. This is required by any OpenGL implementation using X11 and was released as Open Source by SGI in February 1999.
[http://www.sgi.com/software/opensource/glx/]

Utah-GLX

A hardware accelerated implementation of the GLX protocol (the glue layer between OpenGL and X11) for Linux platforms. This driver is currently (2/00) in beta but is planned to eventually support Matrox MGA-G200, MGA-G400, ATI RagePro, Intel i810, NVIDIA Riva and S3 ViRGE graphics cards.
[http://utah-glx.sourceforge.net/]
gmaes: A program for evolutionary biology applications that computes a gamma parameter that accounts for rate variation among sites by counting the minimum number of substitutions for each site for a given tree topology. This is written in C and can be compiled on most platforms.
[ftp://ftp.bio.indiana.edu/molbio/evolve/]
gmake: See GNU Make.
[http://www.gnu.ai.mit.edu/order/ftp.html]
gmap: A geographical map viewer with support for temporary (i.e. time-bounded) data. The functionality includes zooming, animation, database queries, data importation, and time-difference views of maps.
[http://academy.cas.cz/~gis/]
GMCL: The Generative Matrix Computation Library is a C++ matrix computation library created as the result of a comprehensive case study in generative programming. GMCL makes extensive use of expression templates, generative C++ programming idioms, and several template metaprogramming techniques, e.g. control structures for static metaprogramming. The matrix configuration library covers more than 1800 different kinds of matrices resulting from different combinations of matrix qualities such as sparsity, shape, storage format, dynamic/static memory allocation, error checking strategies, etc.
Generative programming is concerned with designing and implementing software modules that can be combined to generate specialized and highly optimized systems to fulfill specific requirements. Such techniques serve to decrease the conceptual gap between program codes and domain concepts, achieve high reusability and adaptability, simplify the management of many variants of a component, and increase efficiency in space and execution time.
[http://www.prakinf.tu-ilmenau.de/~czarn/gmcl/]
GMIS: A set of Fortran subroutines for finding approximate solutions of sparse instances of the Quadratic Assignment Problem (QAP) using a greedy randomized adaptive search procedure (GRASP). This is TOMS algorithm 769 and is documented in Pardalos et al. (1997).
[http://www.acm.org/calgo/contents/]
GMP: The GNU Multiple Precision library is for performing multiple precision arithmetic operations on signed integers, rational numbers and floating point numbers. It is designed to be as fast as possible for both small and large operands, with the speed achieved by using full words as the basic arithmetic type, using fast algorithms, and carefully optimized assembly code for the most common inner loops for many different CPUs. GMP is supposedly faster than any other similar library. The five classes of functions in GMP are: mpz, high-level signed integer arithmetic functions; mpq, high-level rational arithmetic functions; mpf, high-level floating point arithmetic functions; mpn, low-level positive integer, hard-to-use, very low overhead functions (which the first three classes call for almost all calculations); and Berkeley MP compatible functions.
A source code distribution of GMP is available. This is a GNU package and as such can be easily configured and compiled on a wide range of UNIX and other platforms. It is documented ina user's and reference manual available in several useful formats.
[http://www.matematik.su.se/~tege/gmp/]
[http://www.gnu.ai.mit.edu/order/ftp.html]
GMP-ECM: An implementation of the Elliptic Curve Method using the GMP multiple precision arithmetic package. The ECM method is used to factor large integers and this implementation is part of the ECMNET Project to find a factor of 50 digits or more using ECM. A source code version written in C is available as are binaries for several platforms including Linux Intel.
[http://www.loria.fr/~zimmerma/records/ecmnet.html]
GMT: The Generic Mapping Tools are a collection of around 50 UNIX tools that allow the manipulation and graphing of X-Y and X-Y-Z data sets and the output of the results in PostScript format. The data can be manipulated in many different ways and the results can be graphed on a multitude of projections, with just about every imaginable graph attribute easily modified. These can be used via a command line interface although it's much easier to collect a series of commands in an executable shell script that can be quickly modified or copied. Data is stored and handled in either raw ASCII format, native binary format, or a GMT version of the NetCDF format called the grd format.
The programs in GMT include:

blockmean and blockmedian, data filters/decimators;

filter1d, which filters 1-D data sets;

fitcircle, which finds the best fitting great or small circle for a set of points;

grdfilter, for filtering 2-D data sets in the space domain;

grd2cpt, for generating color palette files from gridded files;

grd2xyz, for converting files from 2-D gridded to ASCII triplet format;

grdclip, for limiting the z range in 2-D gridded data sets;

grdcontour, for contouring 2-D gridded data sets;

grdcut, for cutting a subregion from a grd file;

grdedit, for modifying header informatin in grd files;

grdfft, for performing operations on grd files in the frequency domain;

grdgradient, for computing directional gradients from grd files;

grdhisteq, for histogram equalization for grd files;

grdimage, for producing images from 2-D gridded data sets;

grdinfo, for extracting information about grd files;

grdlandmask, for creating masking grd files from a shoreline data base;

grdmask, for resetting nodes outside a clip path to a constant;

grdmath, for performing mathematical operations on grd files;

grdpaste, for pasting together grd files along a common edge;

grdproject, for projecting gridded data sets onto a new coordinate system;

grdreformat, for converting gridded files into other grid formats;

grdsample, for resampling a 2-D gridded data set onto a new grid;

grdtrend, for fitting polynomial trends to grd files;

grdtrack, for sampling a 2-D data set along a 1-D track;

grdvector, for plotting 2-D vector fields;

grdview, for creating 3-D perspective imaging of 2-D data sets;

mapproject, for the transformation of coordinate systems for ASCII data;

minmax, for extracting maximum and minimum values from ASCII data sets;

nearneighbor, for performing a nearest neighbor gridding scheme;

project, for projecting data onto lines or great circles;

psbasemap, for creating a basemap plot;

psclip, for using polygon files to define clipping paths;

pscoast, for plotting coastlines, filled continents, borders, and rivers on maps;

pscontour, for contouring or imaging raw data by triangulation;

pshistogram, for plotting a histogram;

psmask, for creating an overlay to mask out regions on maps;

psmegaplot, for creating poster size plots from PostScript files;

psrose, for plotting sector or rose diagrams;

psscale, for plotting gray or color scales on maps;

pstext, for plotting text strings on maps;

pswiggle, for drawing a time series along a track on maps;

psxy and psxyz, for plotting symbols, polygons, and lines on 2-D and 3-D maps;

sample1d, for resampling 1-D ASCII data sets;

spectrum1d, for computing spectral estimates of a time series;

splitxyz, for splitting xyz files into several segments;

surface, a continuous curvature gridding algorithm;

trend1d, for fitting polynomial or Fourier trends to 1-D series;

trend2d, for fitting polynomial trends to 2-D series;

triangulate, for performing optimal Delauney triangulation and gridding; and

xyz2grd, for converting ASCII triples in a 2-D grd file.

The geographic projections provided by GMT include linear, linear with polar coordinates, Albers conic equal-area, Lambert conic conformal, Lambert azimuthal equal-area, stereographic equal-angle, orthographic, azimuthal equidistant, Mercator, transverse and universal transverse Mercator, oblique Mercator, Cassini cylindrical, equidistant cylindrical, generalized cylindrical, Hammer, Mollweide, Winkel Tripel, Robinson, Eckert VI, and sinusoidal.
A unique feature of GMT is the High-Resolution Coastline Database. This is a five-level database of world coastlines, rivers, lakes, and political boundaries created by the authors from several other available databases. The data from these other sources were processed to create a database of polygons along with ancillary positional information that allow the appropriate utilities to easily distinguish between various geographical features and allow the shading or coloring of, for example, only land or ocean areas. The storage format also makes it easy and quick for the utilities to pick out data from a specific area. This database is available in five resolutions which are, from fine to coarse, full, high, intermediate, low and crude resolutions, with the full resolution database taking up 55.7 MB.
GMT was written for UNIX systems in the C language. As such the freely available source code should compile and install on most UNIX platforms. It has been installed successfully on Cray, Sun, IBM, DEC, HP, SGI, Apple, Next and Linux boxes running some UNIX flavor. The documentation includes a technical reference and cookbook (with many examples) as well as detailed UNIX man pages for all of the utilities. The easiest way to start is to copy one of the examples and modify it for your own purposes. See Wessel and Smith (1991) and Wessel and Smith (1995).
[http://www.soest.hawaii.edu/gmt/]

iGMT

A GUI for the GMT package created using Tcl/Tk. This also comes with support for quite a few geoscience data sets such as topography, gravity, seafloor age, hypocenter, catalogs, plate boundary files, hotspot lists, etc. A user's manual is available in PostScript format.
[http://www.seismology.harvard.edu/~becker/igmt/]
[http://www.rz.uni-frankfurt.de/~braun/igmt/]
GMV: The General Mesh Viewer is a 3-D scientific visualization tool designed to view simulation data from any type of structured or unstructured mesh. The data to be visualized are taken from a properly formatted input file and displayed on the screen. Many functions and capabilities are available via pull-down menus, windows, and mouse controls to modify the way the data is being visualized.
The functions available in the main GMV window include:

front- and back-clipping, a method of moving planes which erases everything in front or back of an invisible plane parallel to the screen;

vector scaling, which controls the relative length of the current vectors;

background color adjustment via an RGB model;

twist, elevation, and azimuth slider bars to, respectively, rotate the object about the X-axis, change the angle in the direction of the Z-axis as measured from the X-Y plane, and change the angle on the X-Y plane as measured from the X-axis;

a light source box to change the location of the light source;

an axes orientation view box which shows the orientation of the axes; and

magnification and interactivity slider bars to control the size and the speed of the interactive drawing.

The file menu capabilities include reading and writing data files, creating attribute files, and creating image files containing snapshots of the visualizations (which are saved in the SGI-RGB format). A display menu features many choices of how to view nodes and their associated vectors and numbers. Nodes can be selected by materials, flags, field ranges, their location inside an arbitrary sphere, or node numbers. Menus for display manipulation by cells, polygons, and tracers are also available.
A calculate menu allows cutlines (i.e. the centerline of a cylinder with a user-defined radius) and cutplanes (i.e. planes onto which data is interpolated) to be defined and various data manipulations to be performed with respect to them. Other menus include those for calculating the distance between two points, calculating data from an existing node, selectively viewing portions of the mesh data field, creating isosurfaces, querying for data about a particular cell or node, creating animation sequences (in regular and flight modes), modifying bounding boxes and center points, modifying color bars and editing colors, setting data limits for the current simulation, changing point sizes and scaling axes, creating subsets of data files, creating time indexes, and adding titles.
The GMV program is available in binary format for SGI IRIX, IBM AIX, Sun Solaris and SunOS, HP-UX, Linux Intel, DEC OSF1, and Cray platforms. It is documented in an 80+ page user's manual available in both PDF and PostScript formats. The Linux binary crashed when it couldn't find a lucidatypewriter bold font with the desired font size of 20 pixels. I tried specifying another default font with the -rn option to no avail so I simply edited the binary and replace the font size value of 20 with 19 which the xlsfonts command showed that I did have. It worked fine after that slight modification.
[http://www-xdiv.lanl.gov/XCM/gmv/GMVHome.html]

Next: Gn-Gz Up: Linux Software Encyclopedia Previous: Fn-Fz Contents

Manbreaker Crag 2001-03-08