Ga-Gm

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z  

Last checked or modified: May 27, 1997

[home / linux ]

 

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://starship.skyport.net/crew/aaron_watters/kwParsing/]

 

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; 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.html]

 

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]

 

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/]

 

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

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. [http://www.disi.unige.it/project/gamma/]

 

GAMORA

The GNU Adaptable Multiplatform Object Routing Architecture is a project to develop an extensible, generic server written in Java. It is planned to provide an adaptable architecture for quickly and easily writing servers for any purpose as well as transparent remote administration and authentication. [http://php.indiana.edu/~scgmille/gamora.html]

 

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/]
[ftp://ftp.mth.pdx.edu/pub/math/gap/ ]
[ftp://pell.anu.edu.au/pub/gap/ ]

  

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]

  

GASP

See the binutils entry for more information on the GNU Assembler Preprocessor.

 

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]

 

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/]

 

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/ ]

 

GCK

The General Convenience Kit is a package of general purpose routines for GIMP plug-in writers and users of the GTK library. The GCK routine collection contains routines for UI construction, color and image handling, vector operations, and math functions. The UI routines include general, listbox, color selector, notebook, and tooltips widget routines. The color routines include those for visual and colormap handling, RGB to GDK conversions, interpolation, color operations, colorspace conversions, and supersampling/antialiasing. The vector functions include those for 2-D and 3-D fucntions as well as for projections. A source code version of GCK 1.0.0 is available (3/98) which can be used with GTK 0.99.7. Documentation consists of online descriptions of each function created from the source code versions.

[http://www.ii.uib.no/~tomb/gck.html]

 

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/]

 

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/]

 

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.ai.mit.edu/order/ftp.html ]

 

gdbtk

A GUI for GDB built using the Tcl/Tk toolkit. [ftp://ftp.cygnus.com/pub/gdbtk/]

 

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.ai.mit.edu/order/ftp.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.icot.or.jp/AITEC/IFS/IFS-abst/088.html]

 

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/]

 

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. [http://www.tu-chemnitz.de/~rath/gelda.html]
[ftp://ftp.tu-chemnitz.de/pub/Local/mathematik/Rath/ ]

 

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/]  

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.shef.ac.uk/~nqs/]

 

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/]

 

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, 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 (1996), 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/]

 

Genscript

This package, also known as 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://www.ngs.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/]

 

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/]

 

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/]

 

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]

 

geophysics software

To be completed.

 

GeoTIFF

A TIFF-based interchange format for georeferenced raster imagery. [http://home.earthlink.net/~ritter/geotiff/geotiff.html]

 

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]

 

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/]

 

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/]

 

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.html]

 

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]

 

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://elib.zib.de/pub/elib/codelib/giant/]

 

GIFLIB

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://earthspace.net/~esr/giflib/]
[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/]

 

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://www.iis.ee.ethz.ch/~kiwi/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/]

 

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/ ]

 

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. Its current (7/96) functionality 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; many effects filters (e.g. blur, edge detection, pixelize, etc.); and 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.xcf.berkeley.edu/~gimp/gimp.html]

 

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 script language, and good display facilities. More later. [ftp://kapteyn.astro.rug.nl/gipsy/]

 

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:8000/gist/]

 

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]

 

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/]

 

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 GUJI toolkit is used to provide a graphical interface. GHC is written in Haskell and generates C as its target code. The Haskell language extensions found in GHC are fully fledged unboxed data types, and secure encapsulated mutable variables and incrementally-updatable arrays. A profiling system is included to find out which parts of a program consume time and/or space. Parallel and concurrent programming are supported. Parallel execution is supported based on a distributed-memory store model which currently sits on top of PVM. A simulator called GranSim can be used to simulate parallel execution on a uniprocessor. Some extensions have been made to Haskell to allow it to express certain classes of explicitly concurrent applications, with the resulting language called Concurrent Haskell.

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.dcs.glasgow.ac.uk/fp/software/ghc/]

 

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/]

 

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://www.pageplus.com/~hsf/sources/glimpsegate/]

 

GlimpseHTTP

A collection of tools that allows you to use Glimpse to search your files using an HTTP interface, i.e. a Glimpse search engine and HTTP gateway. It allows the integration of searching and browsing, and creates index files much smaller than those of similar systems. This should compile and install easily on generic UNIX platforms. [http://glimpse.cs.arizona.edu/ghttp/]

 

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://aips2.nrao.edu/aips++/docs/html/aips%2b%2b.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://wafu.netgate.net/tama/unix/global.html]

 

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.

[http://www.emsl.pnl.gov:2080/docs/global/ga.html]
[http://www.hensa.ac.uk/parallel/libraries/memory/
global-array/index.html ]

 

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]

 

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 ]

 

GL-Space

A 3-D modeler for the X11 environment. [http://www.eece.unm.edu/staff/greywolf/glspace/]

 

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]

 

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 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 stroke fonts, and miscellaneous window management functions. This will install on several workstation systems, including Linux PCs with Mesa. [http://www.sgi.com/Technology/openGL/glut.html]

 

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]

 

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/soest/gmt.html]

 

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]

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z