Up: Linux Software Encyclopedia
Last checked or modified: Oct. 28, 1998
- Paai's Text Utilities
- A collection of programs and scripts for manipulating text files.
They were written by a chap engaged in information retrieval and
All of them depend on the availability of a weighted index which can
be generated by either the SMART package
or by the discrim program listed.
The programs comprising PTU are:
- chain, which tracks chains of words in texts;
- sent_wgt, which takes a weights file and a text file
and prints sentence weights;
- sent_til, which prints sentence number and 2-sentence
- discrim, which computes the discrimination value of words
in text files;
- bigrams, which computes the approximate mutual information
- listwords, which creates lists of words from text files;
- matrix, which creates a cross-tabulated file from a
SMART index file;
- wordsel, which extracts word-file combinations from a
- arg-expand, which expands a range, e.g. a,c-f,..., to
- arfftosvd, which converts an arff file to the input format
- de-matrix, which inverts the effects of matrix;
- docvec, which creates a vector representation of documents
in the Reuters database;
- rocchio, which computes the centroid of positive and
- simil, which compares every vector in a file with a
query and writes the results;
- smallsmart, which computes word-document weights according
to the atc variant of SMART;
- smarttosvd, which converts a three column index to the sparse
matrix format used for svd;
- splitname, which cuts a filename in substrings;
- svdtoarff, which converts the output of svdinterface to a
rectangular interface; and
- doenuplot, a simple front-end for Gnuplot.
A source code distribution of PTU is available.
The programs are written in C and in shell scripts and were developed
on a Linux Intel box.
All are documented in individual man pages.
- Pavia's Active Component Compound
Objects is an object-based
approach to data processing
which is an extension of Tcl and a set
of widgets which extend the Tk toolkit
to support object visualization.
The features of Pacco include:
A generic Pacco viewer (gpv) has been written using the
library and is additionally available.
- a highly dynamic environment where new processing functions or
new types of objects can be auto-loaded at run-time;
- a two-language approach so a command language (Tcl) can be used
for most of the work while critical details can be programmed in C;
- an object model where complex objects can be specified and
updated at run-time by grouping basic components;
- the seamless blending of the programming model for data
processing with the model for the graphical interface;
- access to low-level features in a high-level way for the easy
creation of shared or memory-mapped objects;
- the smart loading of files in foreign formats; and
- object visualization at different levels of customization from
highly automated to highly configurable.
The source code for Pacco is available.
Installation and use require Tcl 7.3 or later and Tk 3.6 or
later, depending upon the version of Pacco which is used.
The package is documented online and in files included in
- A replacement for /bin/install that allows for later uninstallation.
Pack logs all files installed during an install process into a
user-specified package log. This allows it to later automatically
remove any files installed with a given package.
This is compatible with GNU install since it is a wrapper
around that program that calls it.
- A skeleton framework into which source trees can be incorporated to
produce releasable packages.
This contains a general purpose, self-regenerating
makefile and several maintenance scripts to make dependences,
write rules for code modules, and index the code.
- packaging tools
- Packaging or archiving and related software include:
- A security program that monitors and summarizes
network traffic. It does this by placing the network interface into
promiscuous mode and capturing all packets. Each packet is examined
and categorized by Ethernet packet type,
IP protocol number,
TCP/UDP port number, and
multicast address. The total number of bytes including all headers
is record for each packet for each category into which it fits.
Monitoring is performed during intervals at the end of which a counter
record is written to a log file. One should be fairly warned that this
generates about 24 Mb of data per data.
A source code distribution is available which is documented in
a man page.
- The Portable Application Code
Toolkit is a comprehensive,
integrated, and portable software development environment created
for applications having unique requirements not met with available
software. It defines a single, high-level programming interface
that shields developers from different hardware architectures and
operating systems. PACT is ideal for developing portable
numerical simulation, applied science and engineering software,
with such features as:
- a comprehensive set of tools for developing
- rapid prototyping,
- portable and efficient binary data handling,
- a graphics system interface to several
systems (X Windows, QuickDraw, DOS, PostScript,
- support for developing customizable GUIs,
- portable interprocess communication
and control for single CPUs, networks and parallel machines,
- a portable mathematics library,
- extensive support for the generation,
runtime, and post-processing phases of numerical simulation codes,
- a portable Scheme dialect for user extensibility,
- extensive signal processing functionality,
- portable and high-level color graphics rendering, and
- tools for browsing, intelligent
comparison, and graphical display of the contents of binary data
and picture files.
The component parts of PACT are:
- PANACEA, a library of routines to handle data flow controls, I/O
mechanisms, and database management issues which are generic
to all simulation codes;
- PDBLib, a library of file management routines used for storing
and retrieving data in a portable format, i.e. PDB;
- PDBDIFF, a tool for comparing the contents of two PDB and displaying
- PDBView, a tool for interactively browsing
through a PDB file displaying
the contents graphically or textually;
- PGS, an application program interface (API) for graphics which is
independent of the underlying host graphics system which supports
line and text drawing primitives, line and text attributes, bit
maps for handling images, and several rendering algorithms;
- PML, a Portable Mathematics Library containing many math routines
such as equation solvers as well as structure definitions and
related functions provided to aid C programmers in organizing
computations in a mathematical way;
- PPC, a Portable Process Control library to execute and communicate
with other processes in environments which permit such operations;
- SCORE, the core foundation of PACT containing functions to smooth
over differences between different C implementations as well as
several function groups which are used extensively throughout the
- SX, the PACT implementation of the Scheme
language; and ULTRA, a program for the presentation, manipulation,
and analysis of 1D data sets, i.e. X-Y pairs.
The source code is available and has been
tested on AIX, HP-UX, Irix, Linux, MAC, OSF, SunOS, Ultrix and
Unicos systems. A huge amount of documentation is available in
the form of user manuals for all of the PACT program components
available in both PostScript and HTML format.
- The Parallel Applications Development
Environment is a system for facilitating the development
of parallel applications for heterogeneous networked
computers. It can employ any standard message-passing library
for interprocessor communications, but since its main purpose
is development on heterogeneous platforms the current versions
uses the PVM message passing library.
It provides a single GUI which incorporates all of
the essential tools for the development of parallel applications.
PADE incorporates a program organizer, a parallel make utility,
utilities for running PVM programs,
access to standard editors, debuggers, and performance monitors,
and a graphical interface to the structure of the virtual
The features of PADE include:
- starting a project either from scratch or by reading a
configuration file saved from a previous run;
- collecting all the data required to send files to all specified
nodes of the virtual machine;
- allowing the user to edit any specified source file on the
- starting PVM;
- saving project data in a configuration file;
- creating a PVMmake configuration file containing the files and
commands to send to each node;
- executing programs and UNIX commands; and
- providing for the smooth completion of a program, e.g. terminating
stray spawned processes and cleaning up temporary files on each node.
The source code for PADE is available.
The installation and use of this on a UNIX/X11 development
host also requires PVM
The documention consists of user's and installation
manuals available in HTML and PostScript format.
- An object-oriented environment supporting and implementing parallel
adaptive finite element simulations in 2- and 3-D.
PadFEM includes preprocessing GUIs based on both Tcl/Tk
and Java, quadtree/octree-based mesh
generators for 2- and 3-D arbitrary domains,
mesh partitioning algorithms, different solvers,
error estimators, and mesh refinement and load balancing algorithms.
An Xlib-based GUI called XFem is provided
for monitoring, debugging, and postprocessing in 2-D.
A 3-D version used OpenGL.
The parallelization model used by PadFEM is SPMB based on mesh
partitioning. The object-oriented data structure automatically
generates halo elements to provide one-element-wide virtual overlap
at inner boundaries. Adaptivity is supported by functions for
inserting nodes, edges, faces and elements.
Load balancing algorithms use built-in procedures to transfer
elements. Included solvers include multigrid, conjugate gradient,
and domain-decomposition based preconditioned conjugate gradient
The FEM module allows the solution of stationary and nonstationary
Poisson equations with mixed boundary conditions, and will soon
(5/98) have the capability of solving the Navier-Stokes equations.
A distribution is not available as of 5/98, but is promised as
soon as the documentation is considered sufficient for general
- A package which explores multiscale interfaces, i.e. those in
which zooming and panning are a fundamental part of the user's interaction
with the computer.
Zooming and panning are powerful visualization tools for any kind
of hierarchical data, i.e. nested details can be shown at a smaller
scale to show their relationship to large objects and the zoomed
upon to see their details.
They are also techniques that can be applied to file and Web
browsers wherein subdirectories or subdocuments can be preserved
as one navigates below or above them.
Pad++ has capabilities other than just panning and zooming, e.g.
portals or holes through which other regions on the same or another
Pad++ surface can be viewed, turning any object into a hyperlink,
making objects sticky so they ``stick'' to the surface of the
glass and remain stationary while the rest of the objects on the
Pad++ surface move around (which can be used to create automatic
hyper-buttons which float above the Pad++ surface), and
portal filters (or magic lenses) which filter what is seen
The Pad++ distribution consists of C++ code implementing
a Tcl/Tk Pad++ widget and a Paddraw
application which uses the widget.
A version of the Tcl wish shell with Pad++ built-in can be
compiled and used to create zoomable interfaces.
It is available as source code or in binary format for
SGI IRIX, IBM AIX, Sun SunOS and Solaris, and Linux Intel platforms.
Further work is being done on a Pad++ Web browser, creating
Pad++ GUI components, developing Pad++ applications for understanding
large datasets, and more.
Manuals for both Pad++ and Paddraw are available online and as
helper applications within the software.
- A C++ class library supporting distributed
data management and communication that provides for various distribution
mechanisms via underlying distribution libraries.
PADRE seeks to provide a uniform distributed data management interface
in the presence of a multiplicity of distribution libraries,
a choice of communication libraries,
a choice of execution models,
varied computational/communication patterns, and
a variety of architectures.
It also enables better performance than can be obtained when restricted
to the use of a single distribution library since it supports the
simultaneous use of more than one such library.
- A C++ class library for image coding and manipulation.
It supports the PNG, TGA, TIFF, JPEG/JFIF, Windows BMP, and Mac PICT formats.
The PNG, TIFF, and JPEG decoders are based on libpng, libtiff, and libjpeg,
respectively. Data source and destination formats can be tailored as necessary.
Additionally, format-independent but fast bitmap manipulation classes
A source code distribution is available.
- A set of thin-plate and thin-shell
finite element programs that can be
used to model the deformation of the lithosphere, formulate tectonic
hypotheses, fit geodetic data, estimate long-term seismic hazards,
study plate rheology, or for teaching purposes.
The rheology uses in anelastic and the programs incorporate frictional
plasticity and fault sliding and/or power-law dislocation creep and/or
linear Newtonian viscosity depending on local conditions.
The isostatic approximation is used for the vertical equilibrium
component, and the vertical normal stress estimated as lithostatic.
The paleotec programs differ from the related neotec
package in that they perform historical simulations in which finite
strain accumulates for millions of years.
A deforming thermal model is incorporated, and distinct grids for the
crust and mantle layers are used since these can become detached in
The primary program in this package is LARAMY, a program created
to permit simulations of continental deformation in which a crust of
either one or two rheological layers (either one of which may enclose
the brittle-ductile transition) overlies a mantle lithosphere
and/or fluid asthenosphere and/or subducting slabs.
Several other analysis and plotting programs are also contained
within the package, although most of DOS/Windoze specific and
therefore of lesser interest to those on UNIX platforms.
Most of the paleotec programs are written in
Fortran 77 or 90, although some of the
graphics programs are written in the sort of weird languages you
might find on DOS/Windoze platforms since they're developed on
such things. There may also be the odd call or two to IMSL
routines here and there for solving various equation systems.
Documentation can be found online as well as in a series of
papers by the author.
See Bird (1999).
- A program to manage a database of digital music files and allow their
retrieval and playback in many ways.
It works with music files in any format, and formats can be freely
Paloma is a virtual CD player that adds the functionality of managing
a music collection in a relational database.
This allows the playing of all songs, e.g. by a certain artist,
with a given word in the title, of a certain length, etc.
A source code distribution is available.
- Pluggable Authentication Modules is flexible
mechanism for authenticating users.
This is basically a scheme
that allows authentication methods and requirements
to be changed on the fly by encapsulating them in modules that are
compiled separately from the base PAM library and plugged into it
The programs involved in authentication (e.g. login, ftpd, etc.)
need to be modified for the PAM library, but this modification needs to
be done only once for all present and future pluggable modules to be
able to work with those programs.
The development was motivated by the use of methods other than
password entry for authentication, e.g. hardware devices such as
Some of the modules to be found in the PAM source distribution include:
The December 1997 issue of the
Linux Journal contains an
article about PAMs.
- pam_cracklib, for checking the strength of new passwords;
- pam_deny, for denying all forms of access;
- pam_desgold, for use with the Enigma Logic DESGold smart card;
- pam_ftp, for use with FTP daemons;
- pam_kerberos, for use with Kerberos;
- pam_limits, for setting resource limits for a service;
- pam_listfile, authenticates users based on the contents of
a specified file;
- pam_radius, for performing RADIUS
- pam_rhosts, for rhost verification;
- pam_skey, for S/Key authentication; and
- pam_time, for authorization based on time of login.
- PerformAnce ModEling LAnguage is
a project to develop a modeling methodology which yields fast,
parameterized performance models of parallel programs running
of shared- and distributed-memory machines.
PAMELA is also a performance simulation language which supports
a procedure-oriented modeling paradigm, i.e. the application and
machine are modeled in terms of a PAMELA source description and
then a compile-time analysis method is used in which a PAMELA
model is automatically compiled into an explicit analytical
performance model. This method allows low cost and fully
parameterized performance models to be derived which can be
used for automatic system optimization and scalability analysis.
A PAMELA compiler is available which translates PAMELA models
to C which is linked to a PAMELA run-time system library, a
simple, standalone, discrete-event library based on light-weight
The compiler translates PAMELA models to both analytic
performance models and simulation programs.
The compiler is written in ANSI C and can be compiled on
generic UNIX platforms with an appropriate compiler.
The system is documented in a set of technical reports
available in PostScript format.
- The Phylogenetic Analysis by Maximum
Likelihood package is for the phylogenetic analyses of
protein sequences using the method of maximum likelihood (ML).
It can be used to estimate the branch lengths in a phylogenetic
tree and model parameters in the evolutionary model such as
the transition/transversion rate ratio, the shape parameter of
the gamma distribution for variable evolutionary rates among sites,
and rate parameters for different genes.
It can also be used to test hypotheses concerning sequence
evolution, calculate substitution rates at sites, reconstruct
ancestral nucleotide sequences, simulate nucleotide sequence
data sets, and reconstruct phylogenetic trees via maximum
likelikhood and Bayesian methods.
The programs in the PAML package are:
- baseml, for ML analysis of nucleotide sequences, estimation
of tree topology and branch lengths and substitution parameters
under a variety of nucleotide substitution models, constant or
gamma rates for sites, etc.;
- codorml, for ML analysis of protein-coding DNA sequences
using a codon-based model, calculation of the codon-usage table,
and estimation of synonymous and nonsynonymous substitution rates;
- aaml, for ML analysis of amino acid sequences under several
amino acid substitution models, constant or gamma-distributed rates
among sites, among-gene and within-gene variation of substitution
- pamp, for parsimony-based analyses for a given tree topology,
estimation of the substitution pattern, estimation of the gamma
parameter for variable rates among sites by the method of moments, etc.
- mcmctree, for Bayesian estimation of phylogenies using DNA
sequence data and Markov chain Monte Carlo calculation of posterior
probabilities of trees; and
- listtree, for listing all rooted and unrooted trees for a given
number of species, generating random trees with branch lengths from
birth-death process with species sampling, calculating tree bipartition
A source code distribution of PAML is available.
All programs are written in ANSI C and should be portable to any
platform with an appropriate compiler.
The documentation is, unfortunately, in Microshaft Word format.
- A project to produce new data management techniques for
I/O intensive applications that will be useful in high performance
computing. A specific task is to examine the problem of efficient
support for applications that make use of extremely large
multidimensional arrays on secondary storage. The goals of the
project are to provide simpler and more abstract interfaces to
application programmers, to produce more advanced I/O libraries
supporting efficient layout alternatives for multidimensional arrays
on disk and in main memory, and to support high performance
array I/O operations.
A source code for PANDA, written in C++, is available and can
be compiled and used on distributed memory parallel architectures,
networks of workstations, and sequential workstations. Of chief interest
to Linux users is that it currently runs on the UNIX file system
using the MPICH implementation of the
MPI message passing library.
The documentation is available separately in PostScript format.
See also HDFNOW.
See Seamons and Winslett (1996).
- A package which lets the managers of Majordomo
mailing lists subscribe and unsubscribe users, manage archive files,
and change list configurations via the Web.
Pandora is designed to be usable at a screen size as low as
640x480 as well as with Lynx. It makes
extensive use of tables, although non-table users can still get
a clear and readable display. The package is highly configurable
including such things as syslog levels, page coloring, menu
options, computer aliasing, and more.
- An open source framework for the layout and rendering of
Pango uses Unicode for all of its encoding,
and will eventually support output in all the major languages of the world.
The design goals are modularity, font system and tookit independence,
comprehensiveness and quality.
- A framework for creating, rendering and processing 3-D images that
can read a description from a file in any of several supported
scene formats and output an image file into any of several graphics
Panorama is intended to become a complete system with several
supported input and output formats and renderers.
The features of Panorama include:
- a plug-in architecture in which components are loaded as needed
and which is easily extensible;
- an object-oriented scene description language with classes,
inheritance and other OO features (which is itself a plug-in);
- support for ray tracing with other rendering methods to be
- a postprocessing system that lets filters be applied to images
after their generation;
- an object filter attribute in each object that lets a filter
be specified for application on an object basis; and
- a bidirectional scattering distribution function (BSDF) for materials
that encapsulates their properties with respect to light.
A source code distribution of Panorama is available as is a binary
distribution for Linux Intel platforms.
Compilation requires GCC version 2.8.1 and glibc 2.07.
Documentation is as yet (5/98) a bit sketchy.
- The Python active object server is
an active multi-user object server with a simple query language.
The distribution consists of modules which:
implement the storing and locking of objects, the query language, and
the registration of notifications;
implement the network interface of the server;
implement the network interface of a client;
define a class in which all objects to be stored on the server need to be;
implement a number of utility functions.
Example modules are included which:
implement a producer that accepts and stores lines to the server;
implement a consumer that prints out lines produced by a producer; and
implement two-way communication.
A source code distribution of the Python modules which comprise the
package is available.
- Purdue's Adapter for Parallel Execution
and Rapid Synchronization is specialized hardware
which connects unmodified platforms running UNIX or Linux to make
a fine-grained parallel computer. The hardware can be built or
bought (rather cheaply) and can be much more effective than using
conventional networks of workstations with, e.g., message passing
software, since PAPERS cluster even support SIMD and VLIW execution
PAPERS clusters are programmed using a library called AFAPI (the
Aggregate Function Application Program Interface).
Programs are written using the AFAPI library with C or C++, compiled
with gcc, and then executed on a PAPERS cluster (with
future plans including PAPERS compilers for parallel C dialects and
an automatic parallelizing Fortran compiler).
Two software implementations of AFAPI are currently (5/97) available.
SHMAPERS (SHared Memory Adapter for Parallel Execution and Rapid
Synchronization) implements the full user-level AFAPI for SMP
and uniprocessor Linux/UNIX systems which provide the standard System
V shared memory segment operations.
SHMAPERS is entirely bus-lock free which enhances portability and
ensures minimal bus interference during spin-lock operations.
CAPERS (Cable Adapter for Parallel Execution and Rapid Synchronization)
implements AFAPI for precisely two *86-family PCs running
- A world processor for UNIX systems under X11/Motif.
The goal of this project is to create a complete and modern
word processor for document composition. It presently features
a good range of functionality but is still in development.
The three modules that comprise PAPyRUS are a the kernel written
in C++, a TCL command interpreter, and a GUI written in C using
the X11/Motif library.
The presently available functions include text insertion,
image insertion (via the XPM format), a command language,
modification of character and paragraph attributes, several
save formats (ASCII, PostScript, PAPyRUS format), document
printing, and a syntax checker (i.e. ispell).
The source code is available as well as statically and dynamically
linked Linux binaries. The documentation is contained within
a 130 page manual in PostScript format. It is also only
available in French at present (2/97).
- Paradigm Visual Make
- An IDE for C/C++/etc. development built using
Tcl/Tk. It can be adjusted to various
programming languages and source file types and incorporates
text and makefile editors. It also allows external programs
to be executed and their output captured into a specialized
PVM text window.
A source code distribution is available.
- A structured programming language for data-parallel programming
(SIMD) systems. It is based on sequential Modula-2 but extended
with machine-independent parallel constructs.
In Parallaxis an abstraction
is achieved by declaring a processor configuration in functional form,
specifying number, arrangement, and connections between processors.
With these "virtual processors and connections", an application
program can be constructed independent of the actual computer
The system consists of compilers for sequential and parallel computer
systems, a debugger (extensions to gdb and xgdb), and a large
selection of sample algorithms from different areas, especially
The sequential version of Parallax is available as a binary
for Sun SunOS and Solaris, DEC Ultrix, HP 9000, IBM RS6000,
SGI Irix, and Linux Intel platforms. There are parallel versions
for MasPar MP-1 and MP-2, PVM clusters, and the Intel Paragon.
The documentation is contained within a user's manual and
a language definition report, both of which are available
in PostScript format.
See Braunl (1993).
- Parallel Processing Using Linux
- A repository of practical information for those engaging in the
sorcery of attempting parallel processing on Linux platforms.
The plan is to have the usual stuff about parallel processing,
e.g. software, hardware, documentation, etc., but to specialize
in discussing complete parallel environments which integrate
hardware configuration, parallel OS functions, libraries, languages,
parallel I/O, and applications, i.e. the works.
It is also planned to keep a list of open problems that have been
identified in order that they can be tackled by many folks in
- parallel/concurrent programming
- The use of several machines or processors to perform
The January 1988 issue of the
Linux Journal contains
many articles on parallel processing with Linux.
Related and interesting sites include:
Hardware-related entries include:
Languages developed for parallel programming or with parallel programming
- Amoeba, a distributed OS;
- A'UM, a concurrent object-oriented language;
- BETA, an object-oriented language with facilities
for procedural and functional programming as well as the capability for
the concurrent execution of processes;
- Cilk, an algorithmic multithreaded language;
- Clean, a general purpose, higher-order pure and
lazy functional language for the development of sequential, parallel and
- C++//, designed for importing reusability into
parallel and concurrent programming;
- C*, an explicitly parallel language with a compiler
that translates C* code in C code plus calls to a communication library;
- C-Talk, an object-oriented language with
multiple inheritance, parameterized classes, exceptions, multitasking
and persistent objects;
- Erlang, a language designed for building
fault-tolerant, distributed systems with a large number of concurrent
- HPF, a set of parallel extensions to Fortran;
- JAVAB, a tool for automatically detecting
and exploiting implicit loop parallelism in Java bytecode;
- JavaParty, an extension allowing distributed
Java programs to be written;
- JAVAR, a Java restucturing compiler for
making implicit parallelism explicit;
- KLIC, a parallel implementation of a concurrent
logic programming language;
- Modula-2*, a version of Modula with
explicitly parallel high-level constructs;
- mpC, a language developed for writing efficient
and portable programs for a wide range of distributed memory machines;
- NESL, a strongly-typed, applicative,
- OOF, Fortran extensions that support the declaration
and manipulation of objects in support of parallelism;
- Orca, for parallel programming on distributed
systems based on the shared data-object model;
- Parallaxis, a structured language for
data-parallel programming (SIMD) systems;
- Phantom, an interpreted language for addressing
the problems presented by large-scale, interactive, distributed applications;
- Pike, an interpreted and modular object-oriented
language with multi-threading capabilities;
- Reactive-C, a C-based language for
reactive programming with parallel programming capabilities;
- sC++, extensions to C++ for active objects and
synchronization primitives which can produce multithreaded code;
- Sisal, a functional language for developing
parallel scientific computing applications;
- SR, a language for writing concurrent programs;
- TXL, a language and system designed to support
- uC++, an object-oriented language with high-level
- UFO, a language that unites functional and
object-oriented techniques to ease the tasks of developing programs for
- Xi, an interactive language which can use
PVM for distributing computations; and
- youtoo, an object-oriented language with
parallel programming capabilities; and
- ZPL, and array programming language designed
for fast execution on both sequential and parallel machines.
Libraries that implement some sort of parallel or distributed
programming paradigm include:
- ACE, an object-oriented toolkit implementing
fundamental design patterns for concurrent communication software development;
- Adsmith, an object-based distributed shared
memory (DSM) system built on top of PVM;
- ARCH, a library of tools for parallel programming
on machines that uses MPI;
- BSPlib, an implementation of the BSP model of
- C4, C++ classes for expressing
parallel programs using high-level abstractions;
- CHAOS, a C++ runtime library
for parallelizing Fortran and
C programs with irregular data access patterns;
- Counterpoint, a mechanism for communication
and synchronization among the elements of a parallel program;
- CVM, a distributed shared memory (DSM) system;
- DIPC, for creating a multi-computer system
from Linux computers on a TCP/IP network;
- Dome, a library of distributed objects for
- DREAM, a distributed shared memory (DSM) library
built on top of PVM;
- Filaments, a library for creating
architecture-independent parallel programs;
- GAMMA, a library for turning a pool of
machines into an efficient parallel platform for SPMD or MIMD applications;
- Global Array, an efficient and portable
shared-memory interface for distributed memory computers;
- II, a distributed Java
framework providing a generic object model and a variety of messaging models;
- JIAJIA, a distributed shared memory (DSM) system;
- Jsync, a set of synchronization primitives for
Java for developing concurrent applications;
- mEDA-2, an extension to PVM
providing virtual shared memory (VSM) for inter-task communication and
- MPI, a message passing library;
- Nexus, a portable library providing multithreading,
communication and resource management for implementing languages, libraries
and applications in heterogeneous parallel and distributed environments;
- Para++, classes for encapsulating message
passing primitives into a higher level of abstraction;
- p4, a library for programming a variety of
parallel machines in C and Fortran;
- PICL, implements a generic message passing
interface on a variety of multiprocessors;
- PLUMP, for solving PDEs on unstructured,
- PLUS, a transparent communication mechanism
between standard message passing environments;
- PM2, a portable multithreaded environment providing
execution support for highly parallel applications;
- PPI++, an object-oriented message passing library;
- PUB, a C library for developing parallel algorithms
based on the BSP model;
- PVM, a message passing library;
- Quarks, a library for running programs designed
for shared memory multiprocessors on a network of computers;
- SMARTS, supports integrated task and data
parallelism for MIMD architectures with deep memory hierarchies;
- SVMlib, an emulation of shared memory in
a distributed memory environment; and
- TOOPS, for the process-oriented simulation
of communication protocols including message passing.
Parallel programming environments which generally contain a selection
of tools for developing parallel programs in one or more languages or
with one or more libraries include:
- TRAPPER, a graphical programming
environment for developing parallel programs;
- UfMulti, for breaking up data analysis
programs into pieces and running them on multiple hosts;
- VPE, for creating programs based on the message
Miscellaneous tools related to parallel programming include:
- bWatch, a GUI showing load and memory statistics
for each node of a cluster;
- PRNGlib, several pseudo-random number
generators for shared or distributed memory parallel architectures;
Software related to parallel numerical methods or scientific computation,
i.e. applications, include:
- Omega Project,
- Parssim1, an aquifer or reservoir simulator
for incompressible, single phase flow and reactive transport of subsurface
fluids through a heterogeneous, porous medium;
- PMD, for simulating the dynamics of biological
- VIC, a package for describing and solving
CFD algorithms in data parallel fashion.
Software related to parallel I/O (e.g. filesystems and the like) includes:
- FUFS, a parallel filesystem for workstation
- Galley, a parallel file system;
- PANDA, a parallel I/O system for workstation
- PIOUS, a complete parallel I/O system
for the PVM environment;
- PMPIO, a portable implementation of the
MPI2 I/O chapter;
- PVFS, a parallel virtual file system;
- RAID, a group of protocols for creating
and using disk arrays;
- RAIDframe, a rapid prototyping tool
for RAID systems;
- ROMIO, a high-performance and portable
MPI-IO implementation; and
- TPIE, a parallel I/O system.
See also threads.
Almasi and Gottlieb (1994),
Andre et al. (1985),
Carriero and Gelerntner (1990),
Chandy and Misra (1988),
Codenotti and Leoncini (1993),
Dongarra and Tourancheau (1993),
Geist et al. (1994),
Gibbons and Rytter (1990),
Greenlaw et al. (1995),
Hulle et al. (1994),
Gelernter et al. (1990),
Gropp et al. (1994),
Jamieson et al. (1987),
Kumar et al. (1994),
Lakshmivarahan and Dhall (1994),
Nicolau et al. (1991),
Reed and Fujimoto (1987),
Wilson and Lu (1996),
Wolfe (1996) and
Zima and Chapman (1991).
- A program that strenuously tests a programming language implementation's
floating point capabilities.
Separate source code versions of this are available
for C, Fortran (single and double
precision versions), Basic, Modula-2,
- A set of C++ classes that allow message passing programs to be
written by encapsulating message passing primitives into a higher
level of abstraction. All communications are defined by using
C++ streams. These C++ bindings have been implemented on top
of both PVM and
- A project to develop new parallel algorithms for the
direct solution of sparse systems on linear equations and for
the iterative solution of such systems based on either multigrid
or domain decomposition, with any algorithms developed to be
made available in the public domain. The objectives of the
project are to develop sparse matrix algorithms according to
the needs of industry, to implement portable prototypes of these
solvers and to demonstrate them on different HPC systems,
to specify an open library interface for the library,
to integrate the solvers and additional utilities into the
PARASOL library and provide an interface to the programming
to establish continuous library support, and to evaluate
- A package capable of doing formal computations on recursive
types at high speed. It is primarily aimed at number theorists,
but can be used by people whose primary need is speed. Symbolic
manipulation a la Mathematica et al. is possible, but it usually
fares poorly compared to the beforementioned systems. Its main
advantages are speed (for certain classes of applications) and
the possibility of directly using data types familiar to
mathematicians. PARI can be used either as a library called
from any upper-level language application (e.g. C, C++, Pascal
and Fortran) or as a sophisticated programmable calculator (named
GP). Binaries are available for Amiga, Mac, and MS-DOS systems as
well as for several UNIX flavors (e.g. Dec Alpha, HP, Sun SPARC
and Solaris, and Linux). The source code is also available.
It comes with a 150+ page manual. There is an article about this
package in the May 1995 issue of the
Linux Journal. A related
project is a PARI interface to the
Python language called
- PARallel Kernels and BENCHmarks is a comprehensive
set of benchmarks that is generally accepted by both users and vendors
of parallel systems.
The ParkBench system contains several levels of benchmarking.
The first level consists of various low-level benchmarks for
both single- and multi-processors.
The single processor benchmarks aim to measure performance parameters
that characterize the basic architecture of the computer and
the compiler software through which it is used. These include:
- TICK1, measures the interval between ticks of the clock being
used in the measurements;
- TICK2, confirms that the absolute values returned by the
computer clock are correct;
- RINF1, basic arithmetic operations in the form of a set of
common Fortran DO-loops; and
- POLY1 and POLY2, memory bottleneck benchmarks.
The multi-processor low-level benchmarks aim to characterize the basic
communication properties of an MPP. They include:
- COMMS1 and COMMS2, in which nodes send and receive
messages to each other;
- COMMS3, which measures the total saturation bandwidth of
- POLY3, which assesses the severity of the communication
- SYNCH1, which measures the time to execute a barrier
synchronization statement as a function of the number of processors
taking part in the barrier.
The kernel benchmarks attempt to span a reasonably wide range of application
areas by including the most frequently encountered computationally
intensive types of problems. These include:
The compact application benchmarks include codes representative of the
fields in which parallel computers are actually used. These include:
- matrix kernel benchmarks including dense matrix multiply, transpose,
dense LU factorization with partial pivoting, QR decomposition and
- a 3-D FFT kernel benchmark;
- a PDE kernel benchmark consisting of a multigrid kernel; and
- an assortment of other benchmarks including an embarassingly
parallel kernel, a conjugate gradient kernel, a largae integer sort
kernel, and an input/output benchmark.
The last benchmark level consists of an HPF compiler
- PSTSWM, a parallel spectral transform shallow
water model; and
- three computational fluid dynamics codes called the NPB-CFD codes.
A source code distribution of ParkBench is available.
All benchmarks are available through both
PVM and MPI.
A user's manual is available in PostScript format.
- A parallel multilevel graph partitioning and sparse matrix
ordering library which implements a variety of algorithms for
partitioning unstructured graphs and for computing fill-reducing
orderings for sparse matrices.
ParMETIS is useful for parallel numerical simulations involving
large unstructured meshes, e.g. finite element simulations, wherein
it can greatly reduce the time spent in communications by decomposing
the mesh in a way that balances the load and minimizes the number
of interface elements.
The ParMETIS algorithms are based on those in the serial
package METIS, and extend the functionality
of the latter by including routines especially suited for parallel
computations and large-scale numerical simulations.
ParMETIS supplies four major functions:
partitioning an unstructured graph, improving the quality of
an existing partition, repartitioning a graph which corresponds
to an adaptively refined mesh, and computing a fill-reducing
ordering for sparse direct factorization.
The algorithms are based on the parallel multilevel k-way graph
The features of ParMETIS include:
- quick computation of high quality partitions of very large
- the use of geometry information to speed up the run time
of partitioning algorithms without a loss in quality,
- the improvement of partitions produced by other algorithms,
- the quick computation of high quality repartitions of adaptively
refined meshes wherein both the number of vertices that are moved
and the edge-cut of the resulting partition are optimized,
- the computation of low fill orderings for sparse direct factorization
using a node-based nested dissection algorithm, and
- the efficient use of memory for partitioning even very large graphs.
A source code distribution of ParMETIS is available. It is
written entirely in ANSI C and MPI and is
portable to all platforms which support the latter.
A user's manual is available in
PostScript format as are several
technical reports describing the algorithms used.
See also METIS.
- See ARPACK.
- A proxy ARP daemon
for dealing with hosts having out of date implementations of the
Internet protocols that don't understand
This enables a gateway that helps brain-dead hosts by lying to them, i.e. it
sends an ARP reply packet the the gateway's Ethernet address for any host not
on the local subnet. The brain-dead host will then send its traffic
to the gateway thinking that the gateway is the destination.
The gateway will then forward the packet.
When invoked, the daemon probes for all active Ethernet interfaces on a
host and configures the Network Interface Tap (NIT) to receive any
ARP requests arriving on that interface. When an ARP request arrives,
the daemon processes in an appropriate manner.
A source code distribution is available that is documented via
a man page.
- A library of parallel preconditioners for iterative solution methods
for linear systems of equations. The methods currently (3/97)
available include additive and multiplicative Schwarz
preconditioners and generalizd block SSOR.
It currently has a C interface with a Fortran interface planned.
ParPre runs over the
MPI message passing library,
and has been tested on the MPICH implementation.
It also uses routines from the
PETSc library, although they
are included in the ParPre distribution.
This is a component of the
- The PARallel Simulation Environment for Complex
systems is a C-based discrete-event simulation
language that adopts the process interaction approach to discrete-event
In PARSEC an object (i.e. physical process) or set of objects in the
physical system is represented by a logical process, with interactions
among these processes (i.e. events) modeled by timestamped message
exchanges among the corresponding logical processes.
A distinguishing feature is the capability of executing a discrete-event
simulation model using several different asynchronous parallel simulation
protocols on a variety of parallel architectures.
It is designed to cleanly separate the description of a simulation
model from the underlying simulation protocol used to execute it.
This allows a PARSEC program to be executed using the traditional
sequential simulation protocol or one of many parallel optimistic or
There are also powerful message receiving constructs that result in
shorter and more natural simulation programs as well as useful
debugging facilities. PARSEC is derived from
Maisie, and existing programs for the latter
can be converted to the former.
A source code distribution of PARSEC is available. It is written
in C and runs on several platforms including Sun Solaris and
A user's manual is available in PostScript and PDF formats.
- parser generator
- A program that converts a grammar description in some type
of context-free grammar into a program in some target language
to parse that grammar.
This are also known as compiler compilers, since they do
indeed compile compilers.
Available parser generators include
See also the
compiler construction tools,
various package which contain parser generators as part of a suite
- A collection of C extension modules to
tokenize, parse and transform abstract syntax trees for
Python source files.
The extension modules are:
- logicalline, tokenizes and breaks Python source into logical
- pgen, provides a low level interface into Python's built-in
- nodetransformer, transforms parse trees produced by the
pgen parser into abstract syntax tree tuples that are a subset
of those used in the Python2C compiler.
- An aquifer or reservoir simulator for the incompressible, single
phase flow and reactive transport of subsurface fluids through a
heterogeneous, porous, irregular medium.
It can also simulate the decay of radioactive tracers or contaminants
in the subsurface, linear adsorption, wells and bioremediation.
The program uses a technique to map highly irregular physical
domains with hills, valleys, internal faults, strata, etc. to
a rectangular computational domain.
Parssim1 can be run on a serial machine or on a cluster using
the MPI package.
Domain decomposition techniques are used for parallel computations.
The package consists of four main parts:
A source code distribution of this Fortran
package is available.
It is documented in a user's guide in PostScript format.
- driver routines for I/O and managing the coupling between
the flow and transport routines;
- Parcel, for simulating incompressible, single-phase,
saturated flow with wells on geometrically general domains using
a locally conservative, cell-centered finite difference technique;
- ParTrans, a transport routine for simulating multiphase
transport with linear sorption, radionuclide decay, simple chemical
reactions, and wells on general geometry using a locally conservative
method of characteristics called the Godunov Method; and
- a general chemistry routine for handling equilibrium and
kinetic reactions using an interior-point algorithm for minimizing
the Gibbs free energy.
- A GNU project to create a clone of Partition
Magic, i.e. a program for creating, destroying, resizing and copying
partitions. This is still (as of 8/99) in the very early alpha
stage of development, so beware.
- partial evaluation
- A technique/tool for automatic program optimization that is also
known as program specialization. This is not unlike an optimizing
compiler but can be a stronger technique in several ways.
Basically, a source-to-source staging transformation is
performed in which a program and partial data are transformed
into a combined, specialized, and often faster version.
This is accomplished by precomputing the parts of the program
that depend on the partial data.
This technique has been successfully applied to ray tracing,
the FFT, simulations of electrical circuits,
and compiling and compiler generation.
Problem types especially suitable for application of this
See Jones et al. (1993) and
Danvy et al. (1996).
- highly parameterized computations that spend large amounts
of time consulting parameters but which are usually run with the
same parameter settings;
- programs containing many similar subcomputations;
- highly interpretive programs, e.g. circuit simulators,
wherein this technique can remove the time it takes to scan
the object being simulated;
- database query search algorithms; and
- metaprogramming wherein a problem is solved via the design
of a user-oriented language and a suitable interpreter.
Available partial evaluation tools include:
- Particle Simulation Methods
- A page summarizing the various methods used to simulate large
systems of particles, e.g. in astronomy. This also has many links
to available software in each category.
- Particle System (API)
- A set of C++ functions for assisting programs
in simulating the dynamics of particles (with a particle being, in the
abstract sense, a entity with a small set of attributes that dictate
its behavior and appearance).
This is intended for implementing special effects in interactive
and non-interactive graphics applications rather than for scientific
simulations, although it does use Newtonian physics where appropriate.
The API style is intended to be similar to that of
OpenGL, although for particles rather than
The API consists of four sets of functions:
- calls setting the current state of the library;
- calls acting on groups of particles;
- calls operating on and managing particle groups; and
- calls creating and operating on action lists.
- Partition Image
- A utility that saves partitions in
ext2fs, ReiserFS or
FAT 16/32 file system format to an image file.
The image file can be compressed in the
gzip or bzip2 formats,
or split into multiple files for copying onto floppies.
Unlike dd, Partition Image only copies the data portions of a
partition rather than the entire partition, i.e. free blocks as well.
- The Perl Application Server is a set of nested
APIs for writing Web-based intranets in
Java. Most of the APIs are wrappers around
third-party modules. The APIs include:
A source code distribution is available, although documentation is
currently (2/99) a bit sketchy.
- Templates, a wrapper around Text::Template and
- DB, a wrapper around DBI::DBD;
- a Java/Perl RPC API;
- an XML/XSL API; and
- an EJB API.
- An evolutionary successor to Algol developed in 1970 by
Niklaus Wirth at ETH Zürich.
It cleaned up and left out some of the more obscure features
of Algol and added the capability to define new data types
out of existing ones. Pascal also supported dynamic
This is one of the older languages still hanging around that has been
used for numerical analysis over the years.
There is a site specializing in
numerical analysis code for Pascal.
See Jensen and Wirth (1974) and
Pascal-related software includes:
- EFLIB, an application framework implemented
in Object Pascal;
- FPKPascal, a 32-bit Pascal compiler;
- gps, the GNU Pascal compiler;
- ptoc, a Pascal to C/C++ converter;
- p2c, a Pascal to C converter; and
- P-XSC, a Pascal compiler with extensions
for scientific computation.
- A full screen shell for UNIX that is not
unlike Norton Commander.
The features of Pash include:
Source and binary distributions are available for Linux platforms.
- a standard main screen with two windows displaying the contents
of different directories, a menu bar, and a command line;
- a four-window mode;
- a process handling function for viewing all current processes
and sending signals to them;
- an IPC device control function that displays
all the message queues, shared memory, or semaphores active in the
system and allows them to be destroyed; and
- a directory tree function for navigating through directory
- The Program for the Array Seismic Studies of
the Continental Lithosphere at Lamont-Doherty provides
a software package to aid in the field processing of seismic data
collected from RefTek data recorders. The PASSCAL software suite
consists of a set of utility programs for handling various tasks.
These programs can be divided into several categories.
The RefTek data processing programs are:
- ref2segy, which converts data from RefTek to a modified
version of the SEGY format;
- ref2mseed, similar to ref2segy but also converts
any compressed data streams into miniseed files;
- ref2log, same as ref2segy but it only writes a log
- ref2tab, which produces just database tables and logfiles
from the RefTek data;
- tkref, a Tcl/TK GUI to program or interrogate the RefTek DAS;
- refpacket, which prints all packet headers from raw PASSCAL data;
- refcatalog, a diagnostic tool to produce an index of packets
on a RefTek disk;
- refextract and tkextract, command line and GUI interfaces
to extract specific events from a RefTek data stream;
- refgrep, for extractio of specific types of RefTek packets based
on packet type and DAS number;
- diskclear, which clears the data from a SCSI disk written by
- refecho, which echos to standard output the RefTek disk label;
- refdump, which copies from a SCSI disk the data written by
a PASSCAL instrument;
- refserial, which reads raw RefTek data from a serial line;
- refpdata, which converts a RefTek data stream into a PASSCAL
- firfilt, which filters and decimates a trace;
- refclean, which removes and re-syncs erroneous packets from
a data stream;
- disk2dat, a GUI allowing the writing of multiple reftek images
to a single tape;
- refrate, a program for calculating clock offset and drift
information from logfiles;
- clockcor, which determines the clock correction for a given
SEGY file; and
- rateclean, which reads output from refrate and fixes
erroneous one second correlations.
Display software programs are:
Event association programs are:
- pql, which provides a quick way to view SEGY, SAC, mini-SEED
or AH seismic data in an X11 environment;
- psql, which provides summary PostScript output of SEGY or SAC
- clockview, which provides X11 display of external clock phase
- logview, a GUI providing useful graphs of information in
- pmon, which takes a PASSCAL data stream as input and displays
up to six channels in near real-time on X11; and
- tkdf, a script to create a bar graph display of the output
from the UNIX df command.
Miscellaneous programs include:
- reap, which associates trace files with events; and
- creat_table, which reads the logfiles produce by
ref2segy and creates a table with information about each trace file.
Several other programs are also available for dealing with SEGY and
- human2epoch and epoch2human, which take a
RefTek time string and returns the
epoch seconds from Jan. 1, 1970 at 00:00 and vice-versa;
- hexdump, which prints a hexadecimal listing of a file;
- calday, which converts from Julian to calendar days;
- julday, which converts from calendar to Julian days;
- coherence, a suite of spectral analysis programs; and
- position, which calculates 2-D locations using GPS position
A source code distribution of the PASSCAL software suite is available.
It has been successfully installed on Linux Intel platforms and
requires the Tcl/Tk package.
Each program is documented in a separate man page.
- A Java program that transforms context-free
grammars and parses restricted and unrestricted grammars.
The parser can find a derivation for any word for a given grammar,
and the transformer can remove unit, lambda and useless productions
from context-free grammars and convert the grammar into
Chomsky Normal Form (CNF).
A source code distribution of this teaching tool is available.
- Pathetic Writer
- An X Window-based word processor for
Linux which uses Scheme as an
See also the same author's
Egon Animator packages.
- A program for mirroring the contents of
Web documents via HTTP, FTP, Goper and HTTPS (SSL) servers.
The features include:
A source code distribution is available.
- recursive downloading based on links inside HTML documents;
- transformation of Gopher and FTP directories into HTML documents;
- HTML links translated from remote to local or vice-versa;
- support for proxy servers;
- support for authentication against HTTP and proxy HTTP servers;
- several options for defining document set for transfer including
limits on server, domain, prefix, suffix, document tree level,
maximum file size and document type;
- automatic restart of transfer when interrupted;
- several modes including simple recursion, newer versions, single
documents, updating links inside HTML document, etc;
- choice of Xt or GTK
user interfaces; and
- native language support based on gettext.
- The Parallel Application WorkSpace is a software
API library and controller application that can be used to link separate
parallel applications together so they can share parallel data structures
in a simple and efficient manner.
Applications use the API to make their data structures available
for sharing with other parallel programs, even if the applications
have unequal numbers of processors, use different parallel data layout
strategies, or are written in different languages using separate
parallel run-time systems or message passing libraries.
The PAWS controller is used to coordinate the initial connections
between components and between the data structures within components,
and is used to maintain a database of active components and connections.
The PAWS API consists of a set of C++ abstract
interface classes upon which a core C++ API for connecting data with
a PAWS standard data model is built.
C and Fortran interfaces to the core API are also provided.
The data model is extensible for complex data structures that cannot
be represented with the standard PAWS data model.
A source code distribution of PAWS is available.
A C++ compiler is needed as well as the
Nexus metacomputing infrastructure package and
the Tcl scripting language.
Documentation includes a user's guide, a programmer's manual, and
a programmer's reference along with several technical reports.
- The Parallel Basic Linear Algebra
Subroutines are parallel
versions of the BLAS
subroutines for performing basic linear algebra computations.
PBLAS is used as the underlying computational layer for
- See Pbmplus.
- A toolkit for converting various image formats to and from
portable formats and therefore to and from each other. This
cuts down on the number of conversion filters needed.
PBMPLUS also includes some simple tools for manipulating the
portable image formats.
The package is broken into four
parts: PBM (Portable BitMap),
the lowest common
denominator (LCD) format for
bitmaps; PGM (Portable GreyMap),
the LCD format for
grayscale images; PPM (Portable PixelMap),
the LCD format for full color images; and
PNM (Portable aNyMap),
which is not a format itself but rather performs content-independent
manipulations on any of the first three formats as well as handling
external formats which have multiple types.
The four parts are upward compatible in the obvious ways.
The image types which can be converted to PBM are:
Andrew Toolkit raster objects, Xerox doodle brushes, CMU window
manager format, Group 3 FAX, Sun icon, GEM img, MacPaint, MGR,
Atari Degas pi3, X10 or X11 bitmap (XBM), and Bennet Yee face files.
Those which PBM can be converted to are: Gemini 10x, ASCII graphic,
Andrew Toolkit raster object, BBN BitGraph, CMU window manager,
Epson printer, Group 3 FAX, GEM img, GraphOn, Sun icon, HP LaserJet,
MacPaint, MGR, Atari Degas pi3, UNIX plot(5), Printronix, X10 and
X11 bitmaps (XBM), Bennett Yee face files, and Zin Interface Library icon.
The image types which can be converted to PGM are:
FITS, Usenix FaceSaver, HIPS, Lisp Machine bitmap, PostScript image data,
and raw grayscale bytes.
Those which PGM can be converted to are: FITS, Usenix FaceSaver,
Lisp Machine format, and portable bitmap.
The image types which can be converted to PPM are:
GIF, Gould scanner file, IFF ILBM, Img-whatnot, MTV ray tracer,
PC Paintbrush, Atari Degas pi1, Macintosh PICT, HP PaintJet,
QRT, raw RGB bytes, AutoCAD slide, Atari compressed and uncompressed
Spectrum, TrueVision Targa, Xim, XPM, and Abekas YUV.
Those which PPM can be converted to are: AutoCAD database,
GIF, NCSA ICR, IFF ILBM, PC Paintbrush, portable graymap, Atari Degas pi1,
Macintosh PICT, HP PaintJet, X11 puzzle, DEC sixel, TrueVision Targa,
Motif UIL, XPM, and Abekas YUV.
Those which can be converted to PNM are: anything (attempted),
Sun raster, TIFF, and X10 or X11 window dumps.
The which PPM can be converted to are: PostScript, Sun raster,
TIFF, and X11 window dump.
The functions which the many utility routine perform include:
- ordered dithering for color images;
- fractal forgeries of clouds,
planets, and starry skies;
- printing histograms and quantizing colors;
- running a Laplacian Relief filter;
- Bentleyizing a portable graymap;
- edge-detecting or edge-enhancing a portable graymap;
- normalizing contrast in a portable graymap;
- performing arithmetic on two portable anymaps;
- concatenating anymaps; and
- rotating, scaling, shearing, inverting, enlarging, and describing
The source code for the package is available. It is written
in C and can be compiled using either a Makefile or
an Imakefile supplied in the distribution.
ELF binary versions of the package are available at the Linux
Each tool in the package is documented in a separate
man page. A newer version of this with some additional
capabilities is Netpbm.
- An interactive printed circuit board layout system
for X11. It creates layout files consisting of
several mostly independent objects, with the top object being the
layout itself. The lower level objects from which boards are
- vias (i.e. a pin-like object) that can be added and removed
individually, e.g. for defining drill points;
- elements representing the components on the board;
- layers that can be used independently or treated as a group;
- lines used to draw tracks on the board;
- arcs for drawing tracks with right angles;
- polygons for filling large areas with solid copper; and
- text objects for labeling layouts.
The features of Pcb include:
A source code distribution of this C/X11 package is available.
It is documented in a user's manual available in the usual formats.
- undo for destructive commands;
- layer groups for grouping signal layers;
- support for add-on device drivers;
- rat nest generation from simple net lists;
- automatic screen updates of changed regions;
- a simple design rule checker that checks for minimum spacing
and overlap rules.
- A Parallel version of the NCAR
Community Climate Model implemented for
MIMD massively parallel computers using a message passing
The CCM is a package including an atmospheric general circulation
model (AGCM), a slab ocean model, and a surface processes model
to simulate the climate of the Earth given the appropriate
The parallelization strategy decomposes the problem domain into
geographical patches with each processor assigned a subset of
the collection of patches. The physics calculations involve
only grid points and data local to a processor and are performed
in parallel. The dynamics are also computed in parallel using special
algorithms developed for semi-Lagrangian transport, the FFT, and
the Legendre transform.
The PCCM was developed for the Intel Paragon and the IBM SP2 but
will also run on a network of workstations running the
The source code for PCCM is available. It is written in
Fortran 77 and documented in a user's guide available in
- The Purdue Compiler
Construction Tool Set has been
- A small, general purpose finite element
program designed for research and educational use.
PCFEAP is written in Fortran and
permits the solution of both linear and nonlinear problems for
static, quasi-static, and transient behavior.
The program is documented in Zienkiewicz and Taylor (1989) and
Zienkiewicz and Taylor (1991).
- The Preconditioned Conjugate Gradient
package is a system for solving linear equations which employs
various gradient-type iterative methods coupled with preconditioners
of various types. It is designed to be applicable to general linear
systems with special emphasis given to sparse systems which might
arise from the discretization of PDEs arising from physical applications.
It is also designed to give high performance with a nearly identical
user interface across different programming models such as shared
memory, data parallel, and message passing programming interfaces.
The features of PCG include:
- a wide variety of
iterative methods, e.g. the conjugate gradient (CG) and conjugate gradient
squared (CGS) methods, the biconjugate gradient (BCG) and QMR
algorithms, and restarted GMRES;
- a wide variety
of preconditioners including variants of point and block Jacobi;
- predefined matrix storage schemes chosen to provide sufficient
generality to implement a wide variety of sparse problems as well as
to take advantage of the various machine architectures;
- a choice of several levels of access, e.g. a top level
or black box call using
a predefined sparse matrix format, an iterative method level with a
direct communication interface, etc.;
- several matrix preprocessing
options to improve the solution process;
- all package routines available
in single and double precision as well as real and complex versions
(which follow the LAPACK naming conventions);
- a high degree of modularity wherein any combination of preconditioner,
iterative method, matrix format, arithmetic, precision and machine
type can be used to solve a problem; optimization for high performance
on particular parallel machines; and
- portability across several parallel
and scalar platforms.
Several versions of the PCG package are supposed to eventually
be available. Currently (3/97) the FTP site contains uniprocessor
Fortran 77 and Cray YMP versions of the
I compiled the uniprocessor version successfully with
g77 0.5.19.1 with no code modifications being necessary.
The documentation, available separately, includes a reference manual,
an examples manual, a tutorial for beginners, and some technical
reports, all in PostScript format.
See Jourbert (1994).
- A collection of Fortran 77 routines for the piecewise cubic Hermite
interpolation of data.
It features routines to produce a monotone and visually pleasing
interpolant to monotone data.
Routines to determine derivative values include:
The routines used to evaluate, differentiate, or integrate the
resulting functions include:
- PCHIM, used if the data are monotonic or if it is desired
that the interpolant stays within the limits of the data;
- PCHIC, used if neither of the above conditions hold or
if control over boundary derivatives is desired; and
- PCHSP, which produces a cubic spline interpolator in cubic
Hermite form for comparison purposes.
The routine PCHMC is a monotonicity checker and
CHFIV, CHFMC, PCHCE, PCHCI, PCHCS,
PCHDF, PCHST, and PCHSW are internal routines
to perform various tasks.
- CHFEV, to evaluate a single cubic Hermite function at an array of
- PCHFE, used when the interval is unknown or if the evaluation
array spans more than one data interval;
- CHFDV, which evaluates a single function and its first derivative
at an array of points;
- PCHFD, used when the interval is unknown or the evaluation array
spans more than one data interval;
- PCHID, computes the definite integral of a function when the
integration limits are data points; and
- PCHIA, computes the integral over an arbitrary finite interval.
A source code distribution of the PCHIP package is available.
All the routines are written in Fortran 77 and are documented
via comment statements included in each source code file.
This is part of CMLIB.
See Fritsch and Carlson (1980) and
Fritsch and Butland (1984).
- Later. Gripe at me if later hasn't yet arrived and you think it should.
- A set of utilities for dealing with the PCI
bus in Linux include:
A source code distribution is available.
- lspci, displays detailed information about all PCI busses and
devices in the system, i.e. a replacement for the original
/proc/pci interface; and
- setpci, for reading from and writing to PCI device
- The Performance Counter Library is a common interface
for portable performance counting on modern microprocessors,
where a performance counter is a part of the processor that measures
and gathers performance-relevant events occurring in the processor.
PCL is intended to be used by expert programmers who wish to perform
detailed analyses of program performance.
The processors supported include Alpha 21164, SGI R10000, UltraSPARC I/II,
PowerPC 604e and Pentium/PPro/PII.
The PCL API supports:
A source code distribution of PCL is available. It is free for
non-commercial uses and is documented in a user's guide.
- queries for functionality, start and stop of performance counting,
and reading the values of the performance counters;
- nested function calls for performing hierarchical performance
measurements on program sections and subsections;
- distinguishing of performance counting in user, system
and user-or-system modes; and
- calling of functions from C, C++ and Fortran.
- The Personal Computer Memory Card International
an international standards body and trade association
founded in 1989 to establish standards for integrated circuit cards
and to promote interchangeability amongst all platforms.
The PC Card Standard defines a 68-pin interface between the
peripheral card and the socket into which it is inserted.
It also defines a software architecture to provide ``plug and play''
capability across a wide range of products, with the software
comprised of Socket Services and Card Services.
A complete PCMCIA support package for Linux platforms is
- A PC NFS authentication and print request server which supports
ONC clients on DOS, OS/2, Macintosh and other systems.
The printing model supported is based on the use of NFS
to transfer the actual print data from the client to the
When the server receives an authenticatin request, it will log in
the user by validating the user name and password and returning
the corresponding uid, gids, home directory, and umask.
It will also add any entry to the wtmp data base if so desired.
A source code version of this is available which has a makefile
modified for compilation on Linux systems.
It is documented in a man page.
This can be obtained as part of the
Shadow Ina Box tool suite.
- A Fortran 77 code for automatic differentiation.
A sequence of statements describing the functions to be differentiated
are written in a language that is a subset of Fortran 77 with some
extensions. This input produces output code for the derivatives.
The package includes a parser that generates an intermediate code that
can be executed independently from the evaluation routines.
There are also subroutines for the direct computation of function
and gradient values which can be called directly from a user program.
This is TOMS algorithm 746 and is documented
in Dobmann et al. (1995).
- Perl-Compatible Regular Expressions
is a C library of functions implementing
regular expression pattern matching using the same syntax and
semantics as Perl 5.
PCRE has both its own API and a set of wrapper functions
that correspond to the POSIX API.
A source code distribution is available.
- A multithreading library for Linux-based Intel systems which is
based on the POSIX 1003.1 standard for
It contains the sources for the library (libpthreads),
a build environment for both ELF and a.out binaries, and a complete
set of man pages for all POSIX.1c functions.
In addition to the multithreading API, the package provides:
structured exception handling with TRY-CATCH-ENDTRY,
sources to a non-blocking version of the BSD socket library,
non-blocking select() and non-blocking read() and write(),
a large amount of example code,
and several runtime configurable parameters including clock
interrupt interval, default thread scheduling policy,
default thread stack size, and the I/O polling interval.
- An interior-point predictor-corrector linear programming package
for solving optimization problems.
The features include: a set of high-level data structures for
linear programming constructs designed for possible reuse in other
codes; the ability to be invoked both as a stand-alone program and
as a callable procedure; a presolver; and a modular structure which
makes it easy for users to modify the code to experiment with
variants of the current algorithm.
PCx accepts any valid linear program that can be specified in
the MPS format.
The source code is available as are binaries for Sun SunOS and
Solaris, IBM AIX, SGI IRIX, HPUX, Intel Linux, and DEC Alpha
platforms. The source code is written in both C and Fortran
and thus requires compilers for each. The documentation is
contained within a user's guide in PostScript format that
is included in the distribution.
- Pure Data is
an object-oriented graphical programming language for computer music in which
objects are patched together with lines to form a running
The program can be changed at runtime for easy experimentation.
Subroutines are also available for building libraries of PD
- The Graphics Environment for Multimedia is for generating
real-time computer graphics for audio-visual compositions.
It is a collection of external programs for creating
OpenGL graphics from within the
PD program for real-time audio processing.
- A problem specification language developed for the AIPS-98 planning
competition. The syntactic features supported include:
The distribution contains a syntax checker, a solution checker,
several sample domains, and a user's manual.
The package is written in Common Lisp.
- basic STRIPS-style actions;
- conditional effects;
- universal quantification over dynamic universes, e.g. object
creation and destruction;
- domain axioms over stratified theories;
- specification of safety constraints;
- specification of hierarchical actions composed of subactions and
- management of multiple problems in multiple domains using
differing subsets of language features.
- A parser for strict PDDL.
- See PDELIB.
- A Newton-Picard single shooting code.
- A collection of Fortran routines which solve
general systems of nonlinear, initial and boundary value partial differential
equations (PDEs) in one or two space dimensions, with each routine
based on the method of lines.
The components of the package are MOL1D, PDECOL, and
MOL1D solves systems of linear or nonlinear initial and boundary
value problems in one space dimension. It can solve hyperbolic problems
with or without dicontinuities and parabolic equations (including
reaction-diffusion equations). It uses the method of lines based
on equi-spaced finite differences.
PDECOL solves general systems of initial and boundary value problems
in one space dimension with general boundary conditions, with spatial
derivatives allowed to be at most second order. This uses the method
of lines based on the collocation of B-spline basis functions.
PDETWO solves general nonlinear systems of initial and boundary
value problems in two spatial dimensions with quasi-linear boundary
conditions. It uses the mthod of lines based upon finite differences
on a user-specified rectangular mesh.
All of the components of PDELIB are written in Fortran and
available as source code.
Each component is documented in a separate ASCII file which
servers as a user's manual.
See Madsen and Sincovec (1979).
- See PDELIB.
- The Portable Document
Format is the underlying file format for the
family of document interchange products created by
(who also created the
format). Any document that would normally be printed can now
instead be turned into PDF which represents the exact appearance
of the printed document, which can then be viewed with an
In addition to representing the printed pages of
a document, Acrobat supports additional navigational aids such as
hyperlinks, bookmarks, and thumbnail views of images. The Acrobat
Reader is freely available for most platforms, but to create PDF
documents you need the commercially available Adobe PDFWriter
or Distiller products.
PDF is based on Level 2 PostScript although it uses a simplified
and limited set of operators, and no new operators can be defined
and there are no interative constructs. A file is structured
as a number of separate objects, each of which are numbered, which
may refer to each other and appear anywhere in the file.
PDF files cannot as yet (3/97) be sent directly to printers to
obtain hardcopy. They must first be run through a filter to
convert them to PostScript and then printed. This conversion can
be accomplished on Linux platforms using either the Acrobat
Viewer or the
Informative sites include the
PDF Corner, the
PDF Zone, and
the Adobe Acrobat site mentioned above.
PDF-related software includes:
- A library of C routines to build applications for
automatically generating documents in PDF format.
The user must still format and arrange text and graphical objects,
but the library handles the internals of tricky bits about generating
the actual PDF.
This was created chiefly for creating dynamic PDF on the Web.
The features of the PDFlib API include:
A source code distribution of this ANSI C package is available.
A reference manual describing the API is available in PDF format.
- documents of arbitrary length and page format;
- different fonts for text output;
- embedding PostScript font descriptions;
- common vector graphics primitives;
- reading PostScript font metrics from AFM files;
- processing common graphics formats, e.g. TIFF, GIF and JPEG;
- generation of hypertext elements, e.g. bookmarks; and
- various features supported in PDF but not yet accessible via
Acrobat software, e.g. page transition effects like shades and
- A tool for printing PDF files or parts of them
from different directories, recursively from subdirectories, from
FTP and HTTP sites, to a printer or a monitor, and in PostScript
or text format.
It can also be used to similarly print PostScript and HTML files.
A source code distribution is available which requires several
other programs for full usage including
poster, libnet and
- A program to translate TeX source code
files into PDF files.
- A UNIX shell which is
a mostly complete AT&T ksh (Korn Shell) lookalike.
It is constantly under development to make it compatible with
both POSIX and ksh whenever possible.
The ksh was designed to be a compatible extension of the
Bourne shell which added features from the csh and some
new ones of its own, with the latter including:
The ksh should run almost any Bourne shell script and is
a superset of the POSIX shell sh (with the ksh having
served as the primary model for formulating sh).
See Abrahams and Larson (1996),
Bolsky and Korn (1995),
Olczack (1992), and
- interactive editing of the command line including file name
completion and the ability to edit the history list;
- improved function definitions providing local variables and
the ability to write recursive functions;
- extended pattern matching for file names and other constructs
(i.e. a feature similar to regular expressions);
- the ability to extract the portion of a string specified by
a pattern; and
- the ability to switch easily between two directories.
- A Fortran program for calculating the
pressure in an oceanic waveguide using the parabolic equation method.
The PDPE code computes the broadband frequency-space Green's
function of the acoustic pressure in a range-dependent
waveguide using the one-way pseudodifferential parabolic
equation with simplified local mode interactions.
This is documented in a brief user's manual and a technical
report in PDF format.
- A neural network simulation system written in C++.
The features of PDP++ include:
- a full GUI based on the InterViews toolkit;
- a network viewer
that shows network architecture and processing in real time and allows
networks to be constructed via point-and-click actions;
- online graphing of training and testing data;
- online display of the network state either numerically or graphically;
- an environment
viewer that shows training patterns using color or size-based graphical
- a flexible object-oriented design which allows full
mix-and-match simulation construction and easy extension by
deriving new object types from existing ones;
- a built-in scripting language
(CSS) which uses C++ syntax
and allows full access to
simulation object data and functions and includes command-line
completion, a source-level debugger, and standard C/C++ library
functions, script control of processing, generation of training
and testing patterns, routine task automation, etc.;
- generation of scripts from GUI actions; and
- the creation of GUI interfaces from script objects to extend
and customize the simulation environment.
The algorithms supported by PDP++ include:
- feedforward and recurrent error backpropagation with recurrent
BP including continuous, real-time, and Almeida-Pineda models;
- constraint satisfaction algorithms and associated learning
algorithms including Boltzmann macnine, Hopfield models,
mean-field networks (DBM), Interactive Activation and
Competition (IAC), and continuous stochastic networks;
- self-organized learning including competitive learning,
soft competitive learning, simple Hebbian, and self-organizing
maps (i.e. Kohonen nets); and
- mixtures-of-experts using backpropagation experts, EM updating,
and a SoftMax gating module.
PDP++ is written in C++ and is available as source code.
Both the Cfront 3.x and g++ 2.7.2 compilers are supported.
Binaries are also available for Sun, SGI, HP, Linux Intel and IBM AIX
A 250+ page user's
manual is available in PostScript format.
- A flexible printing subsystem designed to replace the
This is designed to replace the old model of queueing, accounting
and nonlocal processing with one in which the workstation processes
everything and submits finalized data to the printer when it first
The features include:
- a modular driver and interface support;
- monitoring jobs through completion;
- checking job status even after completion;
- allowing users to print only files of declared types;
- allowing users to define their own printers;
- multitasking with no queues to clog;
- embedding scripts in the rc files;
- custom command-line options; and
- usable in userspace, i.e. root privileges not required.
- The Program Database Toolkit is a set of tools for
the analysis and processing of C++ code that supports
recent features such as templates and namespaces.
The package consists of two main components:
Four applications have been developed using the DUCTAPE library:
- a C++ IL Analyzer that processes the intermediate language
tree and creates a file in program database (PDB) format essentially
containing the C++ interface of the original source; and
- DUCTAPE, a Database Utilities and Conversion Tools APlication
Environment that is a C++ library for processing and merging PDB files, i.e.
applications access the C++ interface of a PDB file via this library.
- pdbconv, converts PDB files to a more readable format;
- pdbmerge, merges PDB files from separate compilations;
- pdbtree, prints file inclusion, class hierarchy and call graph
- pdbhtml, converts C++ source code into HTML format.
The PDT is used by other applications to automatically generate code.
The TAU instrumentor uses it to prepare C++
programs for profiling and tracing instrumentation, and
SILOON uses PDT to generate glue code that
automates access to C++ routines from programs written in scripting
- A program for computing flood frequency analyses based on the guidelines
in Bulletin 17B published by the Interagency Advisory Committee on
Water Data in 1982.
PEAKFQ uses the method of moments to fit the Pearson Type III
distribution to the logarithms of annual flood peaks.
The skew used may be a generalized skew for a region, from the
Bulletin 17B skew map, computed from the data, or weighted between
the generalized and station skews.
Adjustments can be made for high and low outliers and historic
information, and qualification codes may be used to censor
data from the analysis.
A source code distribution of PEAKFQ for UNIX platforms is
The primary documentation is contained within
This is part of the USGS
Water Resources Applications Software
- The Process and Experiment Automatization
Realtime Language is a language for real time
A binary version of PEARL for Linux Intel platforms is available
via this URL, although the documentation is written
entirely in German.
- The Parallel Exemplar-Based Learning
System is a nearest-neighbor learning system designed for
applications where the instances have symbolic feature values.
PEBLS makes it possible to draw comparisons between nearest-neighbor
and probabilistic approaches to machine learning by incorporating
a capability for tracking statistics for Bayesian interfaces.
It can also perform tests using simple distance metrics for baseline
This has been applied to the prediction of protein secondary
structures and the identification of DNA promoter sequences.
A source code distribution of this ANSI
C package is available.
See Cost and Salzberg (1993).
- A collection of commonly used linear algebra subroutines for
computing the eigensystem of the real standard symmetric
eigensystem problem Ax=x and the general
symmetric eigensystem problem Ax=Hx where
A and H are dense and real matrices with
B positive definite and is an eigenvalue corresponding
to eigenvector x.
PeIGS can, in addition to solving linear algebra problems of the
above type, also handle associated computations such as the
Cholesky factorization of positive definite matrices in packed
storage format and linear matrix equations involving lower and
upper triangular matrices in distributed packed row/column
storages. Dense and real matrices are assumed throughout the
computation, and only double precision is currently (4/97) supported.
PeIGS is designed for parallel and distributed memory computers with
a high startup time for communications, e.g. the Intel Paragon and
the IBM SP-1. It can also be used on workstations linked together
using message passing software such as TCGMSG
The installation procedures creates BLAS
and LAPACK libraries which can be replaced
with optimized version if so desired.
The PeIGS distribution contains the source code, written in Fortran
and C, and can be installed on most generic UNIX systems with compilers
for both. The package is documented in a 50+ page user's manual
in PostScript format included with the distribution.
- A Perl 5 module that provides a set of
functions that allow the sending of encrypted, digitally signed
perl code to a remote machine to be executed and the receiving
and execution of such code in an arbitrarily secure, limited
compartment. The author describes it as ``Java done right.''
These functions enable the Perl coding of algorithms to handle
safe internet commerce, mobile information-gathering agents,
live content web browser helper applications, distributed
load-balanced computation, remote software update, Internet-wide
shared-date applications, and much more.
- Pentium Optimized BLAS
- See under BLAS.
- The Programming Environment based on Petri nets is
a comprehensive set of modeling, compilation, simulation and
verification components for
format methods of software engineering
linked together with an X11-based GUI.
The features and functionality include:
Binary versions of the components of PEP are available for a selection
of platforms including Linux Intel.
Documentation is available in PostScript format.
- components for the design of parallel systems by parallel programs,
interacting finite automata, process algebra, or high-/low-level Petri
- compilers to generate Petri nets from such models;
- simulators that allow automatic or user-driven simulation of
high-/low-level nets and which may trigger the simulation of the
corresponding programs and/or a 3-D model;
- a verification component containing various Petri net indigenous
algorithms to check, e.g. reachability properties, deadlock-freeness,
and verification algorithms; and
- interfaces to various other packages including
SMV and Spin.
- The Primitive EQuation
Model is a simple mechanistic 3-D primitive
equation atmospheric circulation model which uses pressure
coordinates. This model
assumes that the planetary surface is essentially smooth and that
there is sufficient drag acting near the lower boundary to make
the details of the lower boundary conditions (which are very
difficult to apply in pressure coordinates) unimportant.
The pressure levels, level thicknesses, and zonal and meridional
resolution are easily modified.
Almost no physical parameterizations are included except for
simple forms of scale selective damping and Newtonian/Rayleigh
The source code is written in Fortran 77
and a manual is included in TeX format.
See Hoskins and Simmons (1975).
- A Perl script designed to parse C/C++ header
files and automatically generate documentation based on the class
definitions, declarations, and comments found in those files.
It doesn't produced a fixed output format but rather uses
template files, plug-in filters, and user-defined variables
to produce a wide range of output formats.
A source code distribution of this Perl script is available.
A manual is included in the distribution.
- A tool for distributing processes to the least loaded machines on a
network so as to balance the load among all machines.
It is based on daemons that run on each machine and furnish information
about their machine to a central program via
The features include:
A source code distribution of this Perl script is available.
- a site-wide or per-user configuration;
- arbitrary evaluation functions;
- definition of machine groups;
- platform independence via Perl;
- accounting for special processes, e.g. that take a special resource
or shouldn't influence the load;
- extraction of host lists matching a performance-based criterion; and
- use of rsh or ssh or something else.
- A Fortran program for the PERiodic solution of nonlinear
one-parameter-dependent ordinary differential equations using
the HOMotopy method.
PERHOM solves such two-point boundary value problems with period
solutions of an unknown period length using a multiple shooting
approach and a homotopy method.
The source code distribution of this is documented via
comment statements contained within the code itself.
This is part of CodeLib.
- A Starlink Project package designed
to search for periodicities in data, i.e. perform time series analysis.
PERIOD is a menu-driven package with several menu options including:
- INPUT, to read an ASCII file;
- OGIP, to read OGIP FITS table data;
- FAKE, the create fake data using either a user-specified
number of sine curves or a logistic equation for chaotic data;
- NOISE, to add noise to or randomize data;
- DETREND, to detrend data by removing DC bias which would cause
significant power at 0 Hz;
- WINDOW, to set data points to unity to deal with the
problem of spectral leakage;
- OPEN, to open a log file;
- CLOSE, to close a log file;
- PERIOD, to find periodicities using a sub-menu with choices
for selecting data slots, set/show frequency search limits,
calculate the chi-squared of sine fit versus frequency, obtain
a CLEANed power spectrum or a discrete Fourier power spectrum,
perform phase dispersion minimization, calculate a Lomb-Scargle
normalized periodogram, get string-length versus frequency, calculate
periods from the periodogram, enable/disable significance calculations,
and get online help;
- FIT, to fold the data on a given period and zero point and fit
it with a sine curve;
- FOLD, to fold the data on a given period and zero point to
transform it onto a phase scale;
- SINE, to add, subtract, multiply, or divide a sine curve from data;
- PLT, which calls PGPLOT to display a graph;
- STATUS, which returns information on the data slots or the stored
fits in the log file;
- OUTPUT, which writes to an ASCII file; and
- HELP, for online help.
A binary distribution of PERIOD is available for DEC OSF/1,
Linux Intel, and Sun Solaris platforms.
The program is documented in a 15 page user's manual
available in PostScript format.
- PERIOD (ODE)
- A Fortran program for the solution of nonlinear two-point
boundary value problems with periodic solutions of an unknown
period length. PERIOD uses a multiple shooting method
approach to find a solution.
The source code distribution of this is documented via
comments within the code itself.
This is part of CodeLib.
- An interpreted scripting language
scanning arbitrary text files, extracting information therein,
and printing reports based on that information. It's also
a good language for many system administration tasks. This
is probably the most widely used and important scripting
language. I've noticed that it's a love/hate sort of thing
with Perl as epitomized by its creator, Larry Wall, expanding
the acronym PERL as both Practical
Extraction and Report
Language and Pathetically
Lister. But if you're
going to perform net-related adminstration or other tasks, you
probably need to be somewhat familiar with it. The given URL is
to the Perl Language Home Page. You might also want to check
site, which acts
as a coordinating and communication center to connect people,
information, ideas and resources.
Useful Perl resources on the Web include:
Christiansen and Torkington (1998),
Descartes and Bunce (2000),
Dichter and Pease (1995),
Orwant et al. (1999),
Siever et al. (1998),
Stein and MacEacharn (1999),
Wall and Schwartz (1991),
Wall et al. (1996),
Walsh (1999) and
Software packages written using Perl, which modify or
extend Perl, or which require Perl for use or installation include:
- Perl Data Language is an extension that gives Perl the
ability to compactly store and speedily manipulate the large
N-dimensional data arrays ubiquitous in scientific
computing. The goal of this package is to turn Perl into a
free, array-oriented numerical language similar to commercial
packages like IDL and Matlab where simple expressions can
be written to manipulate numerical arrays.
It can be used both via the interactive shell perldl
on the command line or in Perl scripts
via the PDL module.
PDL provides extensive numerical and semi-numerical functionality
with support for 2- and 3-D visualization as well as a variety
of I/O formats.
PDL features and modules include:
- a Perl extension that implements indexing and looping features,
with the former allowing access to the data in a very flexible way, and
the latter providing efficient implicit looping functionality (via
loops implemented as optimized C code);
- PDL::PP, a module for automatically generating PDL routines from
- pdldoc, a shell interface to PDL documentation;
- PDL::Complex, a module implementing complex numbers;
- PDL::FFT, a module implementing FFTs;
- PDL::Graphics::PGPLOT, an enhanced interface to the
- PDL::Graphics::TriD, a generic 3-D plotting interface for
graphing points, lines, surface, etc. and for creating output in
either OpenGL or VRML format;
- PDL::IO::Browser, a 2-D data browser;
- PDL::IO::Pic, implements I/O for several popular image formats
via the converters from the Pbmplus package;
- PDL::Image2D, 2-D image processing functions;
- PDL::Math, extended mathematical operations and special functions;
- PDL::Primitive, over 50 primitive statistical and mathematical
- PDL::Slatec, an interface to the SLATEC
numerical programming library; and
- PDL::NetCDF, an interface to the NetCDF
data storage library.
- Perlfect Search
- A powerful and customizable site indexing/searching package written
The features include:
A source code distribution is available under the
- an indexing system that uses a document vector model for accurate
- a site indexer that preprocesses, digests and indexes an entire
site once to allow fast retrieval of results;
- low memory usage for indexing large document collections;
- configurable exclusion of either individual files or directories;
- a user-configurable list of stopwords for excluding specific
words from the index;
- a configurable minimum length restriction for indexing words;
- keyword-based searches on single or multiple keyword queries;
- advanced search query options, e.g. keyword forcing and keyword
- a fast and lightweight search algorithm for quick results for even
- a fully customizable output layer based on user-defined
- multiple page result display with a customizable number of results
per page; and
- an automatic installation and configuration utility.
- The perl preprocessor is an enhanced version of
cpp, the C preprocessor.
This takes input files and generates Perl scripts
which create similar but better output files.
- A Perl extension for
the PVM message passing
system. This allows the development of applications for
real-time and client/server systems.
- A collection of Perl programs and libraries
for processing SGML documents.
The program collection includes:
- dtd, a library which parses an SGML document type definition (DTD)
and creates Perl data structures containing the content of the DTD;
- dtd2html, a program which generates an HTML
document which itself documents an SGML DTD and allows the hypertext
navigation of an SGML DTD;
- dtddiff, which lists the changes that have occurred in a
DTD, e.g. new elements and attributes, old/removed elements and attributes,
and content rule changes;
- dtdtree, which outputs the content hierarchy tree of the SGML
elements defined in a DTD;
- dtdview, an interactive SGML DTD querying tool which provides
a command-line interface to access element content rules, element
attributes, and the structure of a DTD;
- sgml, a library which parses an SGML document instance; and
- stripsgml, which removes SGML markup tags from a file and
also attempts to translate standard character entity references to ASCII.
The perlSGML package also contains a set of Perl 5 modules including:
- SGML::DTD, a DTD parser;
- SGML::EntMan, an entity manager;
- SGML::FSI, for Formal System Identifiers;
- SGML::ISO8859, a set of ISO-8859 character set routines;
- SGML::Opt, for command-line option parsing;
- SGML::Parser, a document instance parser;
- SGML::SOCat, an SGML Open Catalog parser;
- SGML::StripParser, removes tags from document instances; and
- SGML::Util, general utility routines.
The perlSGML distribution is available as standalone programs written
in Perl 4 or as Perl 5 modules.
Each program is documented in an extensive man page.
- Perl Shell (psh)
- Merges the capabilities of an interactive
shell with Perl.
The goal is to develop a full-featured shell that uses
Perl syntax and functionality for control flow statements and
various other things.
- A collection modules and code that attempt to combine the
Tk widget toolkit and
This results in an interpreted scripting language for making widgets
and programs with GUIs.
The perl/Tk code is a rewrite of
the Tk code that allows easier external linking and calling,
especially by Perl. It is planned to eventually be a "portable Tk"
package which will be a library usable from Tcl, LISP, C++, python,
and other languages besides Perl.
A source code distribution of perlTK is available.
It is documented in a FAQ as well as in a full set of man pages.
- A package which makes using regular expressions in
Java as easy as in Perl.
It provides Perl 5 regular expressions support for Java programs
by allowing regular expressions to be specified exactly as they
would be in Perl. It also takes care of compiling and
caching the expressions and performs the matching, splitting or
A source code implementation of NetComponents is freely available
under the terms of a non-exclusive, non-transferable limited
license whose details are available at the site.
This uses the related OROMatcher
and TextTools packages which are
included in the distribution.
The API is documented in HTML format.
- Perl modules
- A Perl package provides a mechanism for alternative
namespaces to protect packages from interfering with each
other's variables. A Perl module is a reusable package
that is defined in a library file whose name is the same
as the name of the package. Thus this provides a standard
mechanism for extending Perl via external programs.
There are literally hundreds of Perl modules available via
CPAN and elsewhere.
A CPAN bundle is a collection of modules that comprise
a cohesive unit.
Some useful Perl modules include:
- The Portable Expression Template Engine uses
C++ recursively-defined templates for transforming
certain kinds of C++ statements into other statements with the same
effect but higher performance.
For example, it can transform array statements into single loops - a
transformation that is nearly impossible to perform with standard
Expression templates work by creating an object representing the parse
tree of an expression at compile time.
PETE provides facilities for traversing the parse tree, getting information
from the leaves, and combining the results.
It also contains a system for handling type promotions including facilities
for handling user defined types.
In addition to expression evaluation, PETE also provides facilities for
performing arbitrary operations involving parse trees. It allows the
definition of Functors for performing arbitrary operations at the tree
leaves and Combiners that glue together results which can be used, e.g.
to check conformance of the arrays in the expression, print out a textual
version of the expression, or to implement optimizations based on special
characteristics of the arrays in the expression.
PETE has been ported to several platforms and compilers including
Linux with egcs.
It is not yet (11/98) available for download.
- A mailing list processor and manager.
The features of Petidomo include:
- configuration and maintenance of mailing lists via a web browser;
- setting administrator passwords separately for each mailing list;
- a powerful access control language for configuring who is allowed
to do what, e.g. keeping spam out of lists, limiting the number of
people who can post, etc.;
- an archive of posted articles that can be made available via
the Web, a news server, or FTP;
- automatic recognition and redirection of commands meant for the
list server which are posted on the mailing list, i.e. no
more plagues of ``unsubscribe me'' posts;
- a sophisticated mail rescue mechanism which stores a post in
a directory for manual intervention whenever posting or processing
fails due to a bug, faulty mail headers, or misconfiguration;
- virtual hosting, i.e. one server can host an arbitrary number
of mailing lists with each running under a separate domain name;
- runs with all known mail transport agents;
- operation of public forums, closed mailing lists, moderated lists
or secret mailing lists; and
- support for fully encrypted mailing lists using PGP.
A source code distribution of Petidomo 1.3 is freely available for
non-commercial use, scientific or educational purposes. It is
written in C and can be compiled on most UNIX platforms.
Version 2.0 is a commercial product.
It is documented in a user's manual available in HTML and
- The Portable Extension Tools for Scientific
computing is a large suite of data structures and routines for both
uni- and parallel-processor scientific computing. It is intended
especially for the numerical solution of large-scale problems
modeled by partial differential equations, and provides a rich
environment for modeling scientific applications as well as for
rapid algorithm design and prototyping. The latest version (2.0)
for all interprocessor communication
on parallel systems, although it can also run on single processor
machines without MPI.
PETSc consists of components that provide much of the functionality
required for the parallel solution of PDEs.
The components include:
- Vec, which provides the vector operations needed for setting up
and solving large-scale linear and nonlinear problems, including
parallel scatter and gather operations as well as
special purpose code for handling ghost points for regular
- Mat, a large suite of data structures and code for
the manipulation of parallel sparse matrices including
four different parallel matrix data structures, each
appropriate for a different class of problems;
- PC, a collection of sequential and parallel preconditioners;
- KSP, which contains parallel implementations of many popular
Krylov subspace iterative methods, all coded to be immediately
useful with any preconditioners and any matrix data structures;
- SNES containing data-structure-neutral implementations of
Newton-like methods for nonlinear systems; and
- TS, containing code for the time evolution of PDE solutions and
also provides pseudo-transient continuation techniques for
computing steady-state solutions.
Additional features of PETSc include:
- parallel vectors, scatters and gathers;
- parallel matrices including several sparse matrix storage
- easy and efficient parallel matrix assembly;
- sequential sparse matrix direct solvers;
- scalable parallel preconditioners and Krylov subspace
methods including ICC, ILU, block Jacobi, overlapping Schwarz,
CG, GMRES, and Bi-CG-stab;
- scalable parallel nonlinear equation and unconstrained
minimization solvers including line
search and trust region Newton methods;
- simple parallel ODE solvers for applying the method of lines
to large scale nonlinear time-dependent PDEs;
- distributed arrays;
- automatic profiling of floating point and memory usage;
- a consistent interface for all solvers and data structures; and
- intensive error checking.
A source code distribution of PETSc is available.
It can be installed on a wide variety of UNIX flavors
with or without MPICH, including Linux Intel.
Extensive PostScript and on-line documentation is
See Balay et al. (1997).
- The PHIGS Extension to X is an extension to the
core X protocol to provide 3-D grahpics support within the
X Window environment.
The acronym is currently more or less generic since versions 6.0
and later aren't specifically designed for PHIGS, but rather to
support 3-D application programs in general.
So in addition to PHIGS and PHIGS PLUS, PEX supports many other
3-D graphics APIs with display list mode, immediate mode, or
a mixture of both. The standard X11 distribution includes code
for the Sample Implementation (PEX-SI) of the extensions which implement
the functionality defined by the PEX Protocol Extensions.
Also included is PEXlib, the client side library or API for PEX.
See Blake (1993),
Howard and et al. (1991), and
Kasper and Arns (1992).
- Pfau Zeh
- An emulator for the Commodore VIC-20
computer which runs nearly all available VIC-20 software.
It can be used to play games or to write programs in BASIC V2,
and comes with a GUI.
Versions exist for Win32 and Linux Intel.
- The Portable Forth Environment
is an interactive environment for the development
of Forth programs. It is ANS compliant and written
in ANSI C.
- An ANSI-style Forth designed to be portable across
many platforms, with the ``p'' standing for ``portable.''
The features include:
Versions are available for UNIX, PC and Mac platforms.
A reference manual is available as well as a Forth tutorial.
- ANS standard support for the Core, Core Extensions, File Access,
Floating Point, Locals, Programming Tools and String word sets;
- an INCLUDE statement that reads source from normal files
rather than BLOCKS;
- precompiled dictionaries that can be saved and reloaded;
- linking with custom C code;
- a single step debugger;
- smart conditionals;
- conditional compilation;
- local variables; and
- compilation without any stdlib calls for embedded systems.
- A library of macros and subroutines developed at Argonne
National Laboratory for programming a variety of parallel machines in
C and Fortran. Its predecessor was the m4-based "Argonne macros"
system described in the Holt, Rinehart, and Winston book "Portable
Programs for Parallel Processors, by Lusk, Overbeek, et al., from
which p4 takes its name. The current p4 system maintains the same
basic computational models described there (monitors for the
shared-memory model, message-passing for the distributed-memory model,
and support for combining the two models) while significantly
increasing ease and flexibility of use.
The features of version 1.3 of p4 include:
- a library of useful monitors for shared-memory programming;
- portable monitor-building primitives;
- send/receive for shared-memory, distributed memory, and clusters;
- support for heterogeneous computing;
- an Emacs info version of the manual for on-line help;
- shared-memory programming even on uniprocessor workstations;
- instrumentation for automatic logging/tracing;
- either automatic or user-controlled buffer-pool management;
- remote startup, i.e. no daemons necessary;
- optional secure server for faster startup on networks;
- optional automatic logging of events for upshot tracing;
- asynchronous communication of large messages;
- global operations (broadcast, global sum, max, etc.); and
- both master-slave and SPMD models for message-passing programs.
The p4 system is intended to be portable, simple to install and use, and
efficient. It can be used to program networks of workstations,
distributed-memory parallel supercomputers like the Intel Paragon, the
Thinking Machines CM-5, and the IBM SP-1, as well as shared-memory
multiprocessors like the Kendall Square. It has currently been
installed on the following list of machines: Sequent Symmetry (Dynix
and PTX), Convex, Encore Multimax, Alliant FX/8, FX/800, and FX/2800,
Cray X/MP, Sun (SunOS and Solaris), NeXT, DEC, Silicon Graphics, HP,
and IBM RS6000 workstations, Stardent Titan, BBN GP-1000 and TC-2000,
Kendall Square, nCube, Intel IPSC/860, Intel Touchstone Delta, Intel
Paragon, Alliant Campus, Thinking Machines' CM-5, and the IBM SP-1
(TCP/Ethernet, TCP/switch, EUI, and EUI-H). It is not difficult to
port to new systems.
It is documented in a user's manual available in
- A library that offers parallel access to files for a parallel
application running on a cluster of workstations. PFSLib is a parallel
file system library which provides source code compatibility with
Intel's parallel file system PFS.
It is primarily intended to work together with
NXLib as an emulator of a Paragon supercomputer,
but it can also be used as a standalone software product together
with other parallel programming environments like
and other software. PFSLib was tested and
runs on several platforms, including Linux.
This software will apparently be absorbed into a newer project
TOOL-SET for PVM,
although it is still available as a standalone
PFSLib is available as source code. The documentation is contained
within some papers and technical reports available in PostScript
- Port FTP is a program that supports fast data transfer
via TCP and UDP over
unicast, broadcast and multicast modes on either
IPv4 or IPv6.
The features for sending via TCP include:
- sending and receiving directories recursively;
- sending and receiving standard input and output;
- filtering connections (usually with PGP
- orrect timing (in contrast to normal FTP);
- setting aliases for host and user names;
- reducing informational output at a minimum for shell scripts;
- setting the size of strings to be read and written at once;
- setting the net buffer size;
- setting the bandwidth (calibration is 2 seconds, period is 2 seconds);
- starting either as a daemon on any port or by the internet deamon (with
password checking for both);
- sending files and directories with a subject line; and
- performing a network performance test.
The UDP-based data transfer functionality includes:
A source code distribution is available which can be compiled and
used on most UNIX platforms.
Documentation is via a man page.
- sending data as with TCP on the client side, with all received
data written to standard output on the server side;
- sending datagrams via unicast, broadcast or multicast;
- interactively changing the bandwidth; and
- performance a UDP-based network performance test.
- A simple testbed for basic explorations of
Parallel Genetic Algorithms allows multiple
populations with periodic migration among them and a range of
PGA is written in C and can be
compiled and used on most UNIX platforms.
It is documented in a user's guide in LaTeX format.
- A general-purpose parallel genetic
The features include: programs callable from Fortran and C;
runs on uniprocessors, parallel computers, and workstation networks;
binary-, integer-, real-, and character-valued native data types;
object-oriented data structure neutral design;
parameterized population replacement;
multiple choices for selection, crossover, and mutation
easy integration of hill-climbing heuristics;
an easy-to-use interface;
extensive debugging facilities;
and a large set of example problems.
The source code of PGAPack is available and can be installed
and used on most generic UNIX systems. It is written in ANSI
C and uses the MPI message passing
interface for parallel and distributed computations.
The supplied configuration file is set up for several
platforms, including Linux.
The package is documented in a user's guide available in
- A suite of Pentium optimizations for the GCC
compiler developed by the Pentium Compiler Group.
The sources and patches are available as are compiler ports and
binaries for Linux Intel, DOS DJGPP,
FreeBSD, Solaris/X86, and
- See Pbmplus.
- PGM (multicast)
- The Pragmatic General Multicast protocol is a reliable
multicast transport protocol for applications requiring ordered,
duplicate-free, multicast data delivery from multiple sources to
It guarantees that a receiver in a group either receives all data
packets from transmissions or retransmissions, or is able to detect
unrecoverable data packet loss.
PGM is specifically intended as a workable solution for multicast
applications with basic relability requirements rather than as a
comprehensive solution for multicast applications with sophisticated
ordering, agreement and robustness requirements.
- The Precision Graphics Markup Language
is a scalable graphics standard designed by W3C to meet both the simple and
precision needs of various users.
It uses the imaging model common to PostScript
It also contains additional features needed
to satisfy the needs of Web applications including:
Other desirable features that may be added include gradients, patterns,
symbols, a z-depth attribute, and compression.
An extensibility mechanism is also required which will allow the
capabilities to be extended with graphic object types, painting
methods, color spaces, and filter and compositing effects.
- full conformance with other W3C standards;
- background transparency for single and composite objects;
- grouping and naming support for achieving animation capabilities;
- anti-aliasing of text and line art;
- sRGB color space support;
- linking capabilities;
- exporting the imaging model to the DOM;
- creating sophisticated animations via scripting; and
- embedding scripts with PGML.
- Pretty Good Privacy is
a program that gives your electronic mail privacy. It can be used
to encrypt a message or to apply a digital signature to a message
without encrypting it, the latter bit allowing others to confirm if
a message is really from you. It's supposedly illegal to obtain
copies of PGP from the USA from sites outside the USA, so you've
been fairly warned. The given URL is to the EFF PGP archive, which
contains much more information about PGP, its use, the controversy
surrounding its use and distribution, and how to obtain it. Linux
users might find the
PGP and Linux
See Garfinkel (1994), Zimmermann (1995a), and
- PGP shells for, respectively,
KDE and Gnome.
- A Perl script for generating
PGP-signed Web pages. There is also another
script that returns such pages to their original format.
- A library for generating and manipulating PGP
packets without having to run PGP.
The functionality includes:
A source code distribution is available which is documented mostly
in a set of man pages.
- data can be signed with a private key;
- data can be encrypted with a public key;
- data encrypted with a public key can be decrypted;
- signatures on public keys and on buffers can be verified;
- encryption and decryption of convential packets in PGP format;
- armoring and dearmoring a buffer or a file into a buffer or a file;
- reading and writing UserID packets in a variety of format;
- creating literate packages from files or buffers and creating
files from literate packets;
- obtaining keys from a database or by parsing keyrings; and
- maintaining a PGP public-key database.
- A Fortran callable, device-independent graphics library
for making simple scientific graphs which is intended for making
graphical images of publication quality with a minimum of effort
on the part of the user. It consists of two major parts: a
device-independent part written in Fortran 77 and a set of
device-independent device handler subroutines for output on
various terminals, image displays, and printers.
PGPLOT device handlers are available for GIF, HP-GL,
and X Window dump formats; Tektronix and
DEC Regis terminals; Canon, DEC LN03, Epson dot-matrix,
HP Laseret, QUIC, and other printers; PGPLOT graphics
metafile, TeX PK font output, and
environment formats; and much more. There are ports for
several varieties of UNIX (e.g. Linux, SunOS, Solaris, HPUX,
AIX), VMS, NeXTstep, DOS, Windows, Windows/NT, and Mac
platforms. The documentation is contained within a
user's manual available in PostScript format.
The basic PGPLOT package also supports a limited interactive
capability on devices with a cursor for graphical input
(e.g. X Windows workstations), although much greater interactivity
is available via the various front-ends described below.
- A package of subroutines for building interactive
Fortran programs that can be used
to create graphs.
This is built on top of PGPLOT.
- A Perl
module which allows the
PGPLOT graphics library
to be used with the
package with the Perl scripting
language. It makes it easy to process and plot data using the
powerful file and text manipulation facilities built into Perl.
- A collection of Fortran routines designed to enable crystallographic
structures and density maps to be created and displayed with
PGXTAL provides a basic toolkit for general 3-D rendering which
can also create rendered 2-D scientific graphs.
- A Starlink Project application
for interactively plotting data. It is written
to behave similarly to MONGO but to use
PGPLOT as the basic
PONGO features include:
- interactively reading data from a text
- performing complicated mathematical manipulations of the
data using Fortran-like statements that define the required
- the availability of specialized extra data columns,
- many interactive cursor functions,
- drawing error ellipses
and vector plots,
- simple statistical analyses of data,
- data resampling,
- the definition of user-specified functions, and
- the plotting of astronomical position data in any of several
A binary distribution of the PONGO package (along with binary
distributions of the needed ancillary packages) is available for
several platforms, including Linux. The documentation is
contained within the distribution in LaTeX format.
- A Python module that provides an interface
to the functionality of PGPLOT.
- A package that implements
PGPLOT functions as
This allows users to create plots from the command line or
from scripts and, with the addition of various Tcl extensions,
to also create simple graphical user interfaces that allow
direct interaction with plots. It has been ported to HP-UX
Linux, and SunOS platforms with ports to other platforms
on which PGPLOT and Tcl are already installed not a horribly
- A general astronomical data reduction package specially designed for
the analysis of long-slit spectroscopic data.
REDucmE contains programs for I/O, statistics, distortion,
graphical display, error handling, cosmic rays, wavelengths,
flux calibration, extinction correction, sky subtraction, measurement
This is built using PGPLOT and
A source code distribution is available.
- An interactive command line driven plotting program with the
capability of performing simple statistical and data analysis
procedures. It is based on the
PGPLOT graphics library and
the Numerical Recipes routines.
- An interactive package that can be used to produce high
quality scientific graphical output. WIP is basically a
command line user interface built on top of the
library package. It was developed by an astronomer for
use by astronomers but it has much wider application
Salient features of WIP include:
2-D images and automatically sensing the image
type (thus simplifying the overlaying of images with different
resolutions and spatial extents);
- an interpreted language
with variables that allow arbitrarily difficult expressions
to be evaluated internally;
- support for user defineable
macros which can be defined and edited at run time or
read from external files; and
- conditional commands and
loop constructs that allow greater flexibility in the
creation of complex plotting instructions.
The source code for WIP is available and will requires an
ANSI-C compiler for installation. It has been successfully
installed on Sun, VAX/VMS, Linux, Cray and CONVEX systems.
It requires the prior installation of the PGPLOT package
to function. A 150 page user's manual for WIP is available
in Postscript format.
- The Performance Gateway to Real-Time
Tool Integration Environment is
a set of Guile extensions for the integrated
instrumentation and performance analysis and visualization of
parallel and distributed systems.
PGRT-TIE aims to provide an environment for integrating
off-the-shelf tools, extensibility of the environment,
rapid prototyping of on-line performance visualization, and
simplification of analysis of distributed applications.
The PGRT-TIE components include:
A source code distribution is available.
- the Complex System Simulator (CSS);
- the Distributed Rate-Monotonic Scheduler (DRMS);
- the Information System Manager (ISM) which collects and preprocesses
- an external data representation (XDR) extension which provides flexible
access to the XDR protocol for describing and encoding shareable data
- a low-level visual object (LLVO) class; and
- a high-level visual object (HLVO) class.
- An interpreted language designed to address some of the
problems presented by large scale, interactive, distributed
applications such as distributed conferencing systems, multi-player
games, and collaborative work tools. It combines the distributed
lexical scoping semantics of Obliq with a substantial language
core based on an safe, extended subset of Modula-3. It supports
a number of programming features including static structural-equivalence
typing, objects, modules and interfaces, lightweight
exceptions, garbage collection, higher-order functions and lambda
expressions, a keyword binding mechanism, dynamically sized lists,
and type-safe implicit declarations.
The source code for the interpreter, implemented entirely in ANSI-C,
is available. It compiles programs to byte-codes for a virtual
machine similar to that used in Scheme48. Phantom has goals similar
to those that led to the development of
Java, although there are a
number of differences.
It is known to compile
and work on Linux and SunOS platforms.
is presently in alpha release. The documentation includes
a language overview, a language reference manual, and several
technical papers, all avaiable in PostScript format.
- The Polynomial Homotopy Continuation
PACKage implements homotopy continuation methods to compute
numerical approximations to all isolated solutions of a system of
multivariate polynomial equations.
A source code distribution of this Ada
package is available as are binaries for several platforms
including Linux Intel.
A user's manual is available in PostScript format.
- The Programmer's Hierarchical Interactive Graphics
System is a programming interface for the development of 3-D
This standard has been approved as ANSI X3.144-1988,
ISO 9592-1:1989 and FIPS 153.
- The PHIGS Validation Tests consist of a large
set of Fortran and C
programs for testing how well implementations of
PHIGS conform to the standard.
- The Portable High Performance ANSI C
package can automatically generate fast
BLAS-GEMM compatible matrix-matrix
multiply code that reaches near-peak performance on many
machines. PHiPAC uses parameterized code generators, various
C coding guidelines, and search scripts that find the best set
of parameters for a given architecture/compiler combination to
achieve this performance.
A source code distribution of PHiPAC is available. It is
written in C and will not compile with a non-ANSI C compiler.
It can be used with GCC but the performance
increase probably won't be nearly as good as with vendor supplied
C compilers since GCC does a poorer job of optimizing floating
point code than do the latter.
Binary versions of optimized matrix multiply libraries produced
using PhiPAC are available in both single and double precision
versions for various platforms including several Linux/*86
The package is documented via some
technical reports available in PostScript as well as in a set
of man pages.
- A web-based discussion software package written in
The features include:
This PHP package can use either
MySQL or PostgreSQL
as a database backend.
- internationalization of informational messages;
- quoting text from previous messages in replies;
- a complete message thread listing on the reading page;
- navigation to surrounding posts and threads;
- cookies for storing names and email addresses (optional);
- cookies for determining new posts on return visits;
- HTML-encoded email addresses to fight SPAM;
- a search engine;
- collapsible threads;
- moderated posts and censored posting;
- multiple forums on one engine;
- various administrative capabilities including deleting threads,
individual messages, configuring look and feel of forums, etc.;
- limited text decoration via HTML tags; and
- automatic creation of links from URLs enclosed in angle brackets.
- A Starlink Project package
for measuring the sky corrected magnitudes and fluxes of
astronomical objects within circular and elliptical apertures.
PHOTOM can be used to interactively display positions for the
measurements or obtain the positions from a file.
The aperture can be circular or elliptical and its size and shape
can be interactively varied on the display or by entering
values from the keyboard. The background sky level is sampled
interactively by the manual positioning of an aperture or
automatically from an annulus surrounding the object.
The program is used by GAIA.
A binary distribution of PHOTOM is available for DEC OSF/1,
Linux Intel, and Sun Solaris platforms.
The program is documented in a 28 page user's manual available
in PostScript format.
- A web-based image management system designed as a replacement
for tools such as Cumulus. The features include:
- reading Adobe Photoshop description fields as well as standard
JPEG-type comment fields;
- use of an SQL database backend for fast searches;
- automatic adding, updating and deleting of watched repositories
via an included cron script;
- two different thumbnail sizes; and
- secure administration of repositories and cataloging.
- A server-side HTML embedded scripting language that lets
you write simple scripts in your HTML source code files like
The syntax is mostly borrowed from C, Java
and Perl and the goal is to allow Web developers
to quickly write dynamically generated pages.
PHP is similar in concept to Netscape's LiveWire Pro software with the
added features of being fast and free.
It can be used as a standard CGI program, as a CGI program with
support for the new FastCGI standard, or as an
The features of PHP include:
- HTTP authentication when it is running as
an Apache module;
- access logging by individual users
that doesn't use the central access log and provides real-time
- a built-in web-based configuration screen
to handle access control configuration that allows various
restrictions to be placed on files and directories (including
- support for several database systems
including MySQL and
- file upload support;
- support for typed variables and associative arrays;
- conditionals and while loops;
- extended regular expressions;
- raw HTTP header control
- on-the-fly GIF image creation via the gd library;
- error handling and error suppression; and
- a PHP source viewer.
The source code for PHP is available and can be installed on any UNIX
machine running any UNIX web
server. The documentation is
available in HTML format at the site and is also included in
the distribution. There is also an example gallery at the
site that details many possible uses of the software.
Castagnetto et al. (1999),
Hilton and Willis (2000),
Lerdorf (2000) and
- A PHP script that automatically generates front-ends to
- A PHP tool for sending HTML forms via email
in a formatted style.
This also provides some simple statistics.
A source code distribution is available.
- A PHP tool for handling basic
MySQL administrative tasks via the Web.
It can create and drop databases and tables, modify, delete, and
add records and keys, and execute any SQL statement.
A source code distribution is available.
- A PHP library that keeps all web page theme
information in a separate file and thus allows the look of a site
to be quickly changed.
A source code distribution is available.
- A rewrite of the PHP scripting engine that
is 100% downward compatible and much faster.
This is not quite yet (1/99) available, with an initial open
source release scheduled for the first quarter of 1999.
- A multi-user web-based groupware suite written in
PHP that provides an API for developing
The API features include:
- a full object-oriented design;
- session management;
- a database abstraction supporting MySQL
- a network class that handles proxy server connections;
- authentication abstraction supporting SQL,
LDAP, PAM and
SMB authentication protocols;
- sophisticated translation support;
- a file manager class providing applications a way to store and
use user files;
- a templating system;
- application permission based on user and group combinations;
- basic interfaces to all core applications to allow, e.g. the addition
of an item to the calendar via a simple function; and
- various utilities such as browser detection and an
The features of the phpGroupWare framework for application integration
- simple header and footer includes that provide all the API
functions and features;
- loading appname/inc/functions.inc.php directly after system
functions to enable developers to create their own shared functions;
- loading appname/inc/header.inc.php directly below the system
navbar to enable developers to create their own menu systems;
- a directory structure supporting separate project management; and
- making add-ons available by adding the applications via a simple
Many applications are included in the base phpGroupWare system.
- email functionality including connecting to IMAP
or POP3 servers, integration of Usenet newsgroups,
multiple file attachment support, address book hooks, and support
for X-phpGW-Type emails;
- a calendar with private/group/public and re-occurring events support;
- to-do lists;
- a file manager with private and group directories for uploading,
creating, and editing files on the server and directly saving email
- a translation manager; and
- various features and add-ons such as a bookmark program, a trouble
ticket system, chat, forums, headline news, FTP and Napster clients,
a resource booking sytem, an inventory program, and FAX integration.
- A C program designed to perform a wide variety of
aqueous geochemical calculations.
PHREEQC is based on an ion-association aqueous model and its
speciation and saturation index calculations;
reaction path and advective transport calculations involving specified
irreversible reactions, solution mixing, mineral and gas equilibria,
surface complexation reactions, and ion-exchange reactions; and
inverse modeling which finds sets of mineral and gas mole transfers
that account for composition differences between waters.
The improvements of PHREEQC over its Fortran predecessor
- the capability to use redox couples to distribute redox elements
among their valence states in speciation calculations;
- modeling ion exchange and surface complexation reactions;
- modeling reactions with a fixed pressure, multicomponent gas phase;
- calculating the mass of water in the aqueous phase during reaction
and transport calculations;
- keeping track of the moles of minerals present in the solid phases
and automatically determining the thermodynamically stable phase assemblage;
- simulating advective transport in combination with reaction modeling; and
- the use of explicit mole balance equations for hydrogen and oxygen.
A source code distribution of PHREEQC for UNIX platforms is
available. Related programs in the USGS
Water Resources Application Software
series are BALNINPT and
The primary documentation is contained within
- A program for the calculation of geochemical reactions in brines
and other highly concentrated electrolyte solutions using the
Pitzer virial coefficient approach for activity coefficient
corrections. PHRQPITZ is a modification of the geochemical
modeling code PHREEQE, the latter of which has been superseded
The reaction modeling capabilities of PHRQPITZ include:
aqueous speciation and mineral saturation index;
mixing and titration of aqueous solutions;
irreversible reactions and mineral water mass transfer; and
reaction path calculations.
The computed results for each aqueous solution include
the osmotic coefficient, water activity, mineral saturation indices,
mean activity coefficients, total activity coefficients, and scale-dependent
values of pH, individual ion activities, and individual ion activity
coefficients. A database of Pitzer interaction parameters is provided.
A source code distribution of PHRQPITZ for UNIX platforms is
available. This is one of the programs in the USGS
Water Resources Application Software
The primary documentation is contained within
Plummer et al. (1988).
- A multi-threaded, lightweight, and fast Web server.
Phttpd uses features like multithreading, dynamic linking, and
memory mapping to achieve quick response time, extensibility,
and high transfer rates without consuming huge amounts of
This is presently (1/98) only available for computers running
SunOS 5.4 (Solaris 2.4) or later, but it is being ported to
other UNIX variants using POSIX
- A collection of programs for performing
phylogenies on various types of data such
as DNA and protein sequences, restriction sites, distance
matrices, gene frequencies, and quantitative and 0-1 discrete
The programs are grouped into five functional categories:
heuristic tree search algorithms, branch-and-bound
tree search algorithms, interactive tree manipulation algorithms,
tree plotting software, and software for
converting data and making distances or bootstrap replicates.
The programs for heuristic tree searching are:
- PROTPARS, which estimates phylogenies from protein sequences using
the parsimony method;
- DNAPARS, which estimates by the parsimony method
using nucleic acid sequences;
- DNACOMP, which estimates from nucleic acid sequence
data using the compatibility criterion;
- DNAML, which estimates from nucleotide sequences by
- DNAMLK, the same as DNAML but assumes a molecular clock;
- RESTML, which estimates by maximum likelihood using restriction
- FITCH, which estimates from distance matrix data under the
additive tree model;
- KITSCH, which estiamtes from distance matrix data under the
- NEIGHBOR, which estimates using the Neighbor Joining Method
and the UPGMA (average linkage clustering) method;
- CONTML, which estimates from gene
frequency data by maximum likelihood
using a model in which all divergence is due to genetic drift in the
absence of new mutations;
- MIX, which estimates by some parsimony methodsfor discrete character
data with two states; and
- DOLLOP, which estimates by the Dollo or polymorphism criteria for
discrete character data with two states.
The branch-and-bound tree search methods include:
The interactive tree manipulation programs include:
- DNAPENNY, which finds all most parsimonious phylogenies for
nucleic acid sequences;
- PENNY, which finds all most parsimonious phylogenies for discrete
character data with two states for the Wagner, Carmin-Sokal, and mixed
- DOLPENNY, which finds all most parsimonious phylogenies for
discrete character data for the Dollo or polymorphism criteria; and
- CLIQUE, which finds the largest clique of mutually compatible
characters and the phylogeny which they recommend for discrete character
- DNAMOVE, for the interactive construction of phylogenies from
nucleic acid sequences;
- MOVE, for construction from discrete character data;
- DOLMOVE, for construction from discrete character data using the
Dollo or polymorphism parsimony criteria; and
- RETREE, for reading in a tree and allowing rerooting, branch
flipping, and changing species names and branch lengths.
The tree manipulation and plotting programs are:
The data manipulation and bootstrapping programs are:
- DRAWGRAM, which plots rooted phylogenies, cladograms, and phenograms
in a wide variety of user-controllable formats;
- DRAWTREE, for plotting unrooted phylogenies;
- CONSENSE, which computes concensus trees by the majority-rule
consensus tree method; and RETREE.
- DNADIST, which computes four difference distances between species
from nucleic acid sequences;
- PROTDIST, which computes a distance measure for protein sequences;
- SEQBOOT, which reads a data set and produces multiple sets for
- GENDIST, which computes one of three difference genetic distance
formulas from gene frequency data; and
- FACTOR, which takes discrete multistate data with character
state trees and produces the corresponding data set with two
All of the programs are written in ANSI C and thus can be compiled
and used on generic UNIX platforms with an appropriate compiler.
The programs are each documented in separate ASCII text files.
- phylogeny programs
- Available packages include:
- PHYLIP, a package of programs for inferring
- A package which provides a high-level, interactive programming
environment consisting of of a fully procedural programming
language with built-in user-friendly graphics and sophisticated
mathematical analysis capabilities.
PHYSICA provides a wide range of mathematical and graphics
operations including almost 200 mathematical functions, over
30 operators, and varied commands for curve fitting, filtering,
and smoothing. A dynamic array management scheme allows the
use of a large number of arrays of unlimited size, and
algebraic expressions of arbitrary complexity can be evaluated.
Line graphics, histograms, and pie charts are available as
are contour, desnity, and surface plots.
A more detailed list of the features of PHYSICA includes:
Data can be read from and written to ASCII and binary files, with
the capability of digitizing data from a displayed plot or a digitizing pad.
The built-in language features a macro capability with up to 20 nesting
levels and parameter passing, and a macro library of super commands,
nested looping, branching, and conditional statements.
- data interpolation of 1- and 2-D data via various methods
including linear, Lagrange,
weighted splines under tension, and Fritsch-Carlson;
- smoothing data using weighted splines under tension and
- integral transforms of arbitrary expressions;
- FFTs and inverse FFTs;
- data reorganization by sorting, stepping, rolling, wrapping, etc.;
- weighted binning of 1- or 2-D data into automatic or user-defined bins;
- multiple real roots of an expression;
- recursive and non-recursive digital filters;
- manual or automatic determination of data extrema using a graphics cursor;
- fitting data with an arbitrary, nonlinear expression involving up to
- ellipse fitting;
- calculation of parameters for least squares fits using
adjustable parameters; and
- differentiating or integrating arbitrary expressions.
The graphics capabilities of PHYSICA include:
It is also integrated with the EDGR
- multiple graphics windows;
- any number of graphics on a single picture or window;
- display on a wide variety of devices including X11 windows,
VT640, Tektronix 41xx/42xx, PostScript, GKS metafiles, etc.;
- over 40 graphics fonts;
- entry of lines, arcs, and text with dynamic adjustment of
position, size, font, and justification;
- modification of most graphical attributes; and
- area fill functions for arcs and polygons.
Binary versions of PHYSICA are available for VAX/VMS,
Alpha/VMS, Digital UNIX, DEC Ultrix, SGI IRIX, Sun SunOS and Solaris,
HP-UX, IBM AIX, and Linux Intel platforms.
In addition to extensive online help it is documented in a user's
manual over 400 pages long available in
- A set of TeX macros designed to simplify
the formatting and writing of physics papers.
There are two formats available, i.e. PHYSE and PHYS, which
differ in their hyphenation patterns, one being for English and
the other for German.
Each format contains macros for automatically numbering
chapters and sections, creating appendices, making pages,
footnotes, equations, figures, references, and tables.
Each can also list all figure captions, table captions, and
references as well as generate a table of contents.
- A TeX macro package designed to make typing
papers for Physical Review or Nuclear Physics as simple as possible.
It supports cross-references, automatic numbering of sections
and equations, footnotes, itemized lists, and numbered references,
tables, and figures.
- The Program for Information Applications is an
framework for developing flexible and dynamic information
applications. The goal is to simplify the development of document
processing applications by providing a single representation
for describing content and processing that provides the capability
of embedding actions into collections of pages without the need
This framework can be used to build complete, information-intensive
applications called infoware that can be used via any Web browser.
PIA uses XML to specify processing.
The PIA design divides an application into a core processing engine,
a software base called an agency, and task-specific collections
of active XML Web pages called agents.
The agents contain all the knowledged needed for a particular
document processing task and are supported by the agency.
A source code distribution of PIA is available. It requires
JDK 1.1 or greater for installation and use.
Documentation includes several guides in HTML format.
- The Parallel Iterative Alignment package
performs multiple sequence alignment using the parallel
iterative improvement method.
It first performs tentative alignment for all desired
sequences, and then constructs a final alignment using additional
The tentative alignments are performed using a tree-based
combination method which can quickly obtain rough correspondence
The modules that comprise PIA are written in C and KL1.
The distribution can be compiled and used on generic UNIX
platforms on which KLIC has already
A user's manual is included in PostScript format.
- An interactive drawing tool based on the Tcl/Tk package (which
also requires the extended package tclX/TkX as well as the
netpbm/pbmplus utilities). Features include greyscale image
and PostScript object management with interactive rescaling,
rotation, and color control (for PostScript,
PPM, GIF, Pict,
XBM, XPM, X Window and X Region formats), interactive LaTeX
object creation, LateX picture generation mixing PostScript
drawing and LaTeX objects, PostScript generation for subparts of
a drawing allowing creation of big objects hidden by white objects
and selective choice of the interesting region for PostScript
generation, and customization possibilities via Tcl. This should
install on any UNIX machine on which the required packages are
already installed, including Linux boxes.
- The Portable Instrumented Communication
Library is a subroutine library which implements a generic
message passing interface on a variety of multiprocessors.
Programs written using PICL
routines instead of the native commands for interprocessor communication
are portable in the sense that they can be run on any machine on which the
library has been implemented. Correct execution is also a function of
the routines called and the parameter values passed to the routines, but
standard error trapping is used to inform the user when an operation or
parameter value is not legal on a particular machine. Programs written
using PICL routines will also produce timestamped trace data on
interprocessor communication, processor busy/idle times and simple
user-defined events if a few additional statements are added to the source
code. A separate facility called ParaGraph can be used to view the trace
PICL differs from other outwardly similar systems in that it is a
compatibility library with an integrated intrumentation package, and
because it is intended to be a research tool. PICL supports the writing of
portable programs without enforcing it. Machine-specific commands or
functionality can still be invoked when necessary to get good performance.
Portable instrumentation logic that is integrated with the message passing
interface is also a unique feature, one that has proven to be extremely
useful. Understanding the performance of a parallel code often requires the
collection of both system and user-defined event data. Finally, to be a
research tool requires that the code be easy to maintain, easy to extend,
and easy to port to new platforms. Every effort has been made to keep PICL
simple, and to make it available to other research groups who might be
interested in porting it to their multiprocessors.
The PICL source is written in C, but Fortran-to-C interface routines are
also supplied for those machines where that is feasible. To create PICL, you
need picl2.code. Use uudecode and uncompress to generate picl.shar. Next,
unshar picl.shar to create the directory picl2.0. A README file describing
how to create the library is located in picl2.0. Supported platforms
currently include NX/2 (mpsim hypercube simulator, Intel iPSC/2, iPSC/860,
DELTA, Paragon/OSF, and Paragon/SUNMOS), VERTEX (nCUBE/2 and nCUBE/2S), and
PVM 3.3 (SUN and RS6000).
It is documented in a user's manual, a reference manual, and
some technical reports, all of which are available in
- A concurrent programming language
based on the pi-calculus.
Pict is formed in the ML tradition by
adding a layer of convenient syntactic sugar and a static type
system to a tiny core.
The goal in Pict is to identify high-level idioms which arise naturally
when primitives are used to build working programs, e.g. basic data
structures, protocols for returning results, higher-order
programming, selective communication, and concurrent objects.
The type system integrates a number of features found in recent
work on the theoretical foundations for typed, object-oriented
languages, e.g. higher-order polymorphism, simple recursive types,
subtyping, and a powerful partial type inference algorithm.
The Pict distribution contains a Pict-to-C compiler, a reference
manual, a language tutorial, numerous libraries, and example
It is available either as source code or as an executable
binary for Linux Intel and Sun Solaris platforms.
Compilation requires the
Objective CAML compiler.
- Plug-In Drawing, Does Little
Else is a Python module for creating
cross-platform and cross-media 2-D graphics.
It supports screen graphics and file output in a wide range of formats,
making use of the native 2-D drawing calls of each backend for maximum
efficiency and quality.
It works by defining a base class containing methods for all supported
drawing primitives, with particular drawing contexts provided in the form
of derived classes. Applications using PIDDLE can automatically select
an appropriate backend for the environment currently being used.
The available backend renderers include those for
Quickdraw and Adobe Illustrator.
- A high-level, interpreted, and modular object-oriented language.
Pike has a syntax similar to that of C and has powerful built-in
data types that allow simple and fast data manipulation.
The features of Pike include:
- it is interpreted so no compilation and linking are required;
- straightforward and powerful object-oriented features including
- extensibility via modules written in C or Pike;
- several powerful, flexible and efficient data types;
- automatic memory management;
- scalability, i.e. it is as useful for small scripts as for
large and complex applications;
- text processing capabilities for filtering;
- exception handling; and
- multi-threaded capabilities for application development.
Pike is distributed along with a set of modules for performing
various tasks. These modules include:
- Image, an image processing module for performing common
- Sql, an interface to common SQL databases such as
- MIME, a module for MIME documents;
- Gz, a data compression module; and
- Crypto, a cryptographic toolkit.
A source code distribution of Pike is available as are binaries
for several platforms including Linux Intel.
A very large manual is separately available in HTML format.
- Problem Information/Killer Tool is a package
for administering heterogeneous networked workstations.
The primary purpose of PIKT is to monitor systems, report problems, and
automatically fix the problems if possible.
It is a set of programs, scripts, data and configuration files along
with an embedded programming language with many sophisticated features.
The package also includes a centrally-managed per-machine/OS
version control mechanism that is sufficiently general to be used
for other applications.
The components of PIKT include four programs:
Other components include:
- pikt, the script interpreter and all-around workhorse;
- piktd, a cron-like daemon that invokes pikt;
- piktc, the PIKT control program that does everything from
compiling configuration files into PIKT script files to reporting
alarm status to restarting piktd; and
- piktc_svc, a service deamon that responds to administrative
requests from piktc.
- various config files (*.cfg) on the control machine to
register hostnames, define macro substitutions, define alarms,
define support scripts, and specify what is to be monitored;
- various alarm files (*.alt) that are grouped by alerts
and run at regular intervals;
- program files on clients for generating input data or taking
- object files (*.obj) on clients in which things to be
monitored are listed;
- log files (*.log) on the client and control machines for
storing daemon restart times, error messages, executed commands, alert
- history files (*.hst) in which results from several log
files are stored.
Source code and binary distributions of PIKL are available, with
a Linux Intel binary one of the latter.
The distributions contain the package, a test suite, many samples,
- See under Python.
- Parallel Iterative Methods is
a collection of Fortran 77 routines designed to solve systems
of linear equations on parallel computers using a variety of
iterative methods. PIM was designed to allow the user complete
freedom with respect to the matrix storage, access, and
partitioning, and also to achieve portability across a variety
of parallel architectures and programming environments.
The coefficient matrices may be either real or complex, with
PIM routines provided for each in both single and double precision.
The routines are designed to allow the use of left-, right-, or
symmetric-preconditioning to accelerate or obtain convergence,
although they can also be used without preconditioners.
The iterative methods included in PIM include:
conjugate gradients (CG),
bi-conjugate gradients (BICG),
conjugate gradients squared (CGS),
the stabilized version of BICG (BICGSTAB),
the restarted version of BICGSTAB (RBICGSTAB),
the restarted generalized minimal residual (RGMRES),
the restarted generalized conjugate residual (RGCR),
the normal equation solvers (CGNR and CGNE),
the quasi-minimal residual (QMR),
the transpose-free quasi-minimal residual (TFQMR), and
the Chebyshev acceleration (CHEBYSHEV).
The source code for PIM is available.
It has been ported to networks of workstations using
message passing systems such as PVM
and MPI, the SGI Challenge,
the KSR1, the Cray Y-MP2E/232, C9016E and T3D,
the Intel Paragon, the Intel iPSC/860, the IBM 9070 SP/1, and
the TMC CM-5.
A user's guide is avilable in PostScript format.
- PIM (multicast)
- The Protocol Independent Multicast is a multicast
routing architecture for efficiently establishing distribution trees
across wide-area internets where groups are sparsely represented
and bandwidth is not uniform due to both the distances and multiple
The robustness, flexibility and scaling properties of PIM make it
well suited for use with large, heterogeneous internetworks.
- A mail user agent (MUA)
for UNIX systems.
Pine was designed specifically with novice users in mind but can also
be tailored to accomodate the needs of more advanced users.
The user interface was designed to have carefully limited features,
one-character mnemonic commands, always-present command menus,
immediate user feedback, and a high tolerance for user mistakes.
The features of Pine include:
- online help specific to each screen and context;
- a message index showing a summary including status, sender, size,
data and subject;
- several commands to view and process messages;
- a message composer with an editor and spelling checker;
- an address book for saving complex addresses and personal distribution
- message attachments via MIME;
- folder management commands for creating, listing, or renaming
- access to remote message folders and archives via
- Internet news support via either NNTP or IMAP; and
- aggregate operations such as saving a selected set of messages
A source code distribution of Pine is available for UNIX systems as
are binaries for several platforms including Linux Intel.
A user's manual and several other documents are available in
- A set of scripts for using PGP to encrypt and
decrypt messages from inside of Pine.
- A C library for simplifying software development
under UNIX. The contents include:
- several groups of functions and macros
that simplify common tasks like memory allocation, string parsing,
subprocess execution, filesystem traversal, etc.;
- efficient implementations of common data structures, e.g. linked
lists, queues, hash tables;
- a simple, high-level interface to the Berkeley socket IPC
mechanism including routines for socket control, socket I/O, and
network information lookup; and
- a scheduler with functionality similar to that found
- A complete enviroment for the automatic benchmarking of document
page segmentation algorithms.
It consists of three parts:
GroundsKeeper, a Motif tool
for easily creating and editing segmentation ground-truth;
Cluzo, a tool for benchmarking document page segmentation; and
segmentation ground-truth, a set of suites of ground-truthed
documents used for testing and improving the benchmarking algorithms.
The GroundsKeeper tool allows a user to display a document
image and draw zones of various types around the different page
regions using simple mouse clicks.
The zones can be rectangles, constrained polygons, or arbitrary
polygons, and can be deleted, moved, or modified after their creation.
The created regions are given unique IDs and displayed on the screen.
Ordering relationships are specified by clicking on regions in
sequence with the sequence identified as a succession of arrows.
Cluzo is a region-based approach to benchmarking document
page segmentation where quality is assessed by comparing the
segmentation output (described as a set of regions together with
their types, output order, etc.) to the corresponding ground-truth.
The system is flexible and can be customized to benchmark virtually
any type of segmentation task.
A source code distribution of the PinkPanther environment
is available. It is written in C and requires an X11 environment
with the Motif library for compilation
The distribution contains documentation for the package.
- A C++ library for arbitrary precision
arithmetic operating on natural and integer numbers.
Piologie is portable to all systems and independent of
all compilers because it uses only one basic data type which
allows the programs to be written in a higher-level language
than assembler with no significant loss in speed.
It uses the overloading mechanism of C++ and allows mathematical
expressions to be written in conventional mathematical form.
A source code distribution of Piologie is available.
It is written in C++ and can be compiled on just about every
available platform/compiler combination via a series of
make files supplied.
The documentation is currently (11/97) written in German.
- The Parallel Input OUtput System
is a complete parallel I/O system for the PVM
distributed computing environment.
PIOUS implements a fully functional parallel file system on top
of PVM similar to how PVM implements a virtual multicomputer on
top of a heterogenous network of computers.
PVM applications have transparent access to shared permanent
storage via PIOUS library functions.
This package is intended as both a platform for supporting high-performance
parallel applications and as a vehicle for parallel file system
PIOUS implements the functionality found in most parallel file
systems and also has a number of extra features such as:
- 2-D file objects and logical file views;
- coordinated file access with guaranteed consistency semantics;
- data declustering for scalable performance;
- transaction support and user-selectable fault tolerance modes;
- extended file maintenance primitives for managing declustered files; and
- both C and Fortran language bindings.
A source code distribution of PIOUS is available.
It is written in C and should compile and install on most
UNIX systems which have a PVM installation.
It is documented in a user's manual as well as in several
technical reports, all of which are available in
- A system for managing multi-protocol connections between objects
distributed on the Internet.
Networks, programs, files, widgets, etc. are all treated as objects
and represented in a GUI as the nodes of a flow chart.
These nodes can be joined with lines that depict links for data
flow, procedural steps, relationships, etc.
Only the iconic representation of an object resides on the local
machine, with the compute intensive programs and large data
sets located elsewhere.
The two main components of Piper are:
- an XML language for dynamically assembling
components across networks to construct new components; and
- a GUI that makes this easy for end users.
The available node types in Piper are:
- Documents, i.e. files containing one or more data that can be processed;
- Converters that change data formats from one type to another;
- Processors that modify data;
- Viewers that display data for the user;
- Containers, i.e. nodes that store other nodes, acting as both
databases and a file system by allowing a query of documents stored as files;
- Decisions, i.e. control structures that allow Piper to be a graphical
- Widgets, i.e. GUI components for the construction of interfaces;
- Terminators that start or stop workflow; and
- Composites, i.e. nodes that represent and entire portion of a
work flow diagram.
- A project to develop a free, open and extensible workbench for
automatically analyzing and transforming scientific and signal
PIPS can be used for many tasks including whole program
compilation, reverse engineering, program verification,
source-to-source program optimization, and
Fortran 77 code with or without HPF directives
is transformed by PIPS into several types of output including:
- call, control flow and dependence graphs;
- transformed, optimized and restructured Fortran 77; and
- Fortran 77 with commented information, doall (parallel loops),
Cray directives, OpenMP, PVM or MPI.
The code transformations performed by PIPS include:
The available analyses and restructurations include:
- coarse grain parallelization;
- expression optimizations;
- forward substition;
- loop distribution, interchange, normalization, reduction and
- partial evaluation;
- parallelization; and
- strip mining.
- array privatization, section privatization and element regions;
- call and control flow graphs;
- continuation conditions;
- memory effects;
- program complexity;
- reduction detection;
- scalar variable privatization;
- use-def chains;
- atomization and cloning;
- control, dead code and useless defintion elimination; and
- declaration cleaning.
The components of PIPS include:
- pipsmake, a make system that enforces consistency across
analyses and modules;
- pipsdbm, a resource manager that stores all results in a
database for future interprocedural analysis ;
- newgen, which manages data structures by providing basic
manipulation functions for data structures described in a declaration file;
- Linear C3, a library that handles vectors, matrices, linear
constraints and structures;
- pips, a shell interface;
- tpips, a command-line interface and scripting language;
- wpips, epips and jpips, a set of
Source and binary distributions of PIPS are freely available, with
one of the latter being for the Linux Intel platform.
Documentation is scattered across many technical reports, all
of which are included in PostScript format in the distributions.
- A collection of programs for digital signal processing and
auditory modeling that communicate via UNIX pipes.
The collection includes programs that generate, transform,
and store or plot waveforms, with all communication between programs
performed via pipes.
The programs in pipewave include:
- add, sums waveform files;
- append, concatenate waveform files;
- autocorr, correlate waveforms;
- bit, bit-shift data in waveform files;
- downsample, downsample data;
- extract, extract part of a waveform;
- fbank, filter data with a gamma-tone filterbank;
- ffilt, filter data in the Fourier domain;
- fft, Fourier transform data;
- fir, create a FIR filter;
- gaussian, generate noise;
- hanning, Hanning window data;
- hilbert, Hilbert transform data;
- histogram, create a histogram of wave sample values;
- ift, inverse Fourier transform data;
- iht, inverse Hilbert transform data;
- jeffress, cross-correlate/cancel data;
- klatt, create a sine wave synthesis of data;
- oversample, oversample data;
- pdp, learn data using 2 or 3 layer PDP nets;
- plot, plot data;
- rms, report statistics of data;
- unwrap, unwrap the phase of a Fourier analysis;
- warp, dynamically time warp a waveform;
- wfc, combine waveform files into multi-channel files; and
- wfs, split multi-channel files into separate files.
A source code distribution of pipewave is available. It is written in
C and can be compiled and used on most generic UNIX boxes.
Compilation requires a program contained within the
Each program is documented in a separate man page.
- The Parallel Information Processing
System converts data between the portable image
map format (PNM) and the
PIPS also can perform several operations on NetCDF files
in parallel using the PVM
message passing package.
A source code distribution of PIPS is available.
It is written in C and requires the PVM package for its
- The Position, Intensity and Shape Analysis
system is a
Starlink Project package
of routines that deal with the location and parameterization of
objects on an image frame.
The core of the package is a routine called PISAFIND which
performs image analysis on a 2-D data frame. It searches the
data array for objects which have a minimum number of connected
pixels above a given threshold and extracts the image parameters,
e.g. position, intensity, shape, for each object. The parameters
can be determined using thresholding techniques or an analytical
stellar profile can be used to fit the objects.
The deblending of overlapping sources can be performed in
PISA can also perform simple object classification by the simple
thresholding of an additionally generated peakedness measure or
by the multivariate analysis of a set of intensity corrected variables.
The other routines in the package include:
- PISAPLOT, which plots the results of PISAFIND as a series
of ellipses on a graphics device;
- PISAFIT, which fits the PISA analytic stellar profile to
a list of objects;
- PISAGEN, which generates analytic objects and places them
in an NDF data array;
- PISAPEAK, which modifies the PISAFIND parameterizations
to produce variables which are nearly intensity independent;
- PISAKNN, which performs non-parametric multivariate discriminant
analysis on the results from PISAPEAK;
- PISACUT, a utility routine for separating any file into two
given a threshold value for a particular variable;
- PISAMATCH, a utility program for matching indices between
- PISA2CAT, which converts any of the PISA results files into
catalogues which can be used by the CURSA or CATPAC packages;
- PISA2ARD, which converts the results from the PISAFIND
routine into an ARD description of ellipses;
- PISAGREY, which plots an NDF data array as a greyscale; and
- ADDNOISE, which adds noise to model data.
A binary distribution of PISA is available for DEC OSF/1, Linux
Intel, and Sun Solaris platforms.
The program is documented in a 38 page user's manual available in
- The Platform for Implicit Surfaces and
Curves and the Exploration of Singularities is
a project which attempts to supply the mathematical and
scientific communities with numerical tools to compute and
visualize implicitly defined curves and surfaces.
The goals of the project are to create a software package containing:
a set of known continuation algorithms for computing implicitly-defined
curves and surface included both piecewise-linear and
predictor-corrector methods; a command language for batch processing
and high level programming;
a graphical interface for choosing and controlling algorithms; and
new algorithms for computing the structure of singular curves and
A beta version (5/97) of Pisces is available in source code form.
It is written in C
and can be compiled and installed on generic UNIX platforms
that also have the Tcl/Tk toolkit.
The Geomview package is also suggested
although not required.
The program is documented in several manuals and tutorials available
in both HTML and
- The Pasteur Institute Software Environment
is a tool for generating Web interfaces for molecular biology
This package will take an abstract definition of a program's
parameters (e.g. command line parameters, simple interaction on
standard input, and parameter files)
and generate an interface chosen from a set of
available configuration modules.
A source code distribution is available. Installation and use
require Perl 5 and some of the modules
for that distribution.
- See CONTIN.
- The Programmable Interactive Toolbox for
Seismological Analysis is a program for the interactive
analysis of seismological data. It contains numerous tools for
digital signal processing and routine analysis.
It is supported on several platforms including Linux Intel.
The manual is in PostScript that is inscrutable to GhostScript,
so I haven't much more to say about this right now.
- A multithreaded, highly configurable and extensible
HTTP server and development environment for
cross-platform Interner server development and deployment.
The features of Pi3Web include:
- easy portability via the use of a platform abstraction library
that provides a standard interface to files, shared libraries,
threads and synchronization objects;
- configuration files that outline a schema which dictates how
loadable classes and objects are linked and nested together;
- a CGI loadable handler for dispatching browser requests
to CGI programs;
- a Fast CGI loadable handler;
- a library that provides dynamic loading functionality so server
components can be loaded on demand and the server extended without
compilation or linking;
- HTTP caching proxy capabilities;
- a thread execution model for higher concurrency with less use
of system resources;
- compliance with HTTP 1.0 and some features of 2.0;
- a comprehensive server programming API consisting of libraries
providing 189 functions for threads, files, processes, utilities,
shared libraries and HTTP functionality;
- an option to allow the reuse of browser-server connections across
- support for server-side includes;
- virtual hosting; and
- customizable logfiles.
A source code distribution of Pi3Web is available as are binaries for
several platforms including Linux Intel.
Documentation is available in HTML format.
- Pixcon is a 3D renderer and a set of graphics libraries while
Anitroll is an animation system that works with Pixcon. The is
no graphical user interface so programs must be run either
interactively or via a job script. Pixcon is not a ray tracer,
(although it can do a rudimentary and quick sort of ray tracing called
ray casting) and, as such, it is much faster than systems that
render via ray tracing (although not in real time).
The capabilities of Pixcon include a choice of fast polygonal
rendering or ray casting (i.e. 1 level deep ray tracing), fake
shadows and transparency, the use of 3D texture/shaders,
support for 2D texture mapping for most rendering primitives using
lerp and mipmaping antialiasing techniques, support for several
rendering primitives (e.g. polygons and bi-planes, spheres/ellipsoids,
cylinders, cones, surfaces patches, radiant spheres, points/lines,
camera, light source, and more), saving rendering as a series of
RGB images, rendering to any screen dimension, support for
multiprocessing, and more. Anitroll, whose output is designed to
be rendered by Anitroll, supports hierarchical forward kinematics
with flocking flight and particle behavior for simple animation
The source code for Pixcon/Anitroll is available and is supported
on Linux and IRIX 5.2/5.3/6.0 systems, with the latter assuming
the SGI GL library is present and the former using the
Mesa GL clone library.
The documentation is contained in a manual that comes with
the distribution. There is also an online version of the manual.
- A pixmap editor for editing, for example, colored icons.
The source code is available and should install on generic
- A small and fast compiler for an important superset of the
Java language. Pizza also extends Java
with three new features: parametric polymorphism which is
superficially similar to C++ templates although based on the
typing systems of ML and Haskell; first-class functions which
may be passed as parameters, stored in variables, and returned
from methods; and class cases and pattern matching.
Pizza compiles programs to ordinary Java byte code and interfaces
with existing Java code, retaining the compatibility of Java.
All of the old Java libraries can also be used with Pizza, and
binaries can be used as applets.
Pizza is implemented on top of the JDK (although other Java-compatible
virtual machines will also work). The Pizza compiler pc is a
straight replacement for Sun's javac compiler. The pc compiler
works just like javac except that it's 2-3 times faster.
It can currently be installed and used on UNIX platforms for
which a JDK exists as well as on Windows 95 platforms.
The language definition and several technical reports are
available in PostScript format.
- A free, Open Source
Java class library for
parsing, manipulating and creating Adobe PDF
The distribution also contains pjscript, a script interpreter
for creating and modifying PDF files.
This requires JDK 1.1 or greater.
- This OS project has been renamed from pk to
- A system for testing random numbers that consists of an implementation
of the pLab protocol and the pLab library.
The protocol defines a set of rules for the cooperation of software
components from which various tests can be constructed. It provides:
The library is a set of software components that adhere to the protocol
- a pLab tree, i.e. a unified way of defining, implementing and
documenting a test;
- the automatic derivation of statistical information;
- automatic consistency checks; and
- high efficiency.
Implementations are available in C++,
Smalltalk 80 and Mathematica.
Documentation includes a reference manual and several technical reports.
- high-performance implementations of standard random number
- modules from which various tests can be constructed; and
- devices for using the package with existing random number generators
or existing tests without any reprogramming.
- ProLog And Modeling is an implementation
of an algebraic modeling language in
PLAM exploits the natural advantages of using logic programming
for mathematical programming tasks, and allows the user to
formulate problems in a high-level and declarative manner.
Prolog predicates can be used to incorporate familiar
algebraic notation, and the system will automatically generate
the corresponding input for a mathematical programming solver.
The source code distribution of PLAM will run under either
the commercially available SICStus Prolog or the freely
It supports the built-in solver of the SICStus implementation
as well as the commercial CPLEX solver and the
freely available lp-solve.
The language and the ideas between it are documented in a
technical report available in PostScript
- The Programming Language for Active
Networks is a resource-bounded functional programming
language which uses a form of remote procedural call to
realize active networking.
It is designed to be a public, authentication-free layer
in the Active Network hierarchy, and as such its expressive
power is limited to guarantee that all programs will
terminate and reasonably permit a router to run any PLAN
program. PLAN can also be used as a glue layer which
allows access to higher-level services, with the combination
of both allowing much of the flexibility of active networking
without sacrificing security.
An Active Network is one which allows routing elements to
be extensively programmed by the packets passing through them
which enables optimizations and extensions of current
as well as the development of fundamentally new protocols.
A source code distribution of PLAN is available.
It is written in Java and contains
the Java class files, source code, documentation, and
The JDK 1.1.1 Linux port is needed
as well as the Pizza class files
to use this package.
Compiling the code from source additionally requires
the JavaCC parser generator.
The documentation includes an installation guide,
a tutorial, and a programmer's guide, all available in
- Plan 9
- A distributed computing environment assembled from separate machines
acting as terminals, CPU servers, and file servers.
The components are connected via various kinds of networks, e.g.
Ethernet, Datakit, modem connections, ISDN, etc.
Typically, users interact with applications that run either on
their terminals or on CPU servers, with the applications getting
data from file servers.
Plan 9 is an operating system written from the ground up. It is
strongly influenced by UNIX but not a replacement for it.
It is designed to fully exploit three basic ideas: (1) all the
system objects present themselves as named files that are manipulated
by read/write operations; (2) all these files may exist either locally
or remotely and respond to a standard protocol; and (3) the file
system name space is dynamically and individually adjustable for each
of the programs running on a particular machine.
This means that application programs don't need to know where or on
what kind of machine they're running.
Plan 9 is highly portable and runs on four major machine architectures
(including x86 Intel). It supports symmetric multiprocessing in that
both the CPU and file servers are multi-processor machines.
The distribution includes compilers for C and other languages along
with all of the commands and program development tools found in the
It also provides some new software tools including:
Alef, a new language providing threads, inter-process and
inter-machine communication via typed channels, and abstract data types;
Acid, a programmable debugger that understands multiple process
Acme, a new user interface in which any word on the screen
can be interpreted as a command by clicking on it, and any string
can specify a file to be displayed.
Various parts of the Plan 9 system have been emulated on UNIX/X11
platforms. These include:
See 9 (1995b) and 9 (1995a).
- Wily, a mouse-oriented,
text-based working environment based largely on Acme;
- Sam, a multi-file screen editor with structural
- rc, a re-implementation of the Plan 9 shell;
- 9wm, an X11 window manager emulating
the Plan 9 window manager called 8 1/2;
- 9term, an 8 1/2 terminal emulator; and
- 9menu, a program that allows the creation of X
menus from the shell where each menu item will run a command (which can
be used from 9wm or any other window manager).
- The Parallel Linear
Algebra PACK is a library infrastructure
for the parallel implementation of linear algebra algorithms and
applications on distributed memory supercomputers such as the Intel
Paragon, IBM SP2, Cray T3D/T3E, SGI PowerChallenge, and Convex
Exemplar. This infrastructure allows library developers, scientists,
and engineers to exploit a natural approach to encoding so-called
blocked algorithms, which achieve high performance by operating on
submatrices and subvectors. This feature, as well as the use of an
alternative, more application-centric approach to data distribution,
sets PLAPACK apart from other parallel linear algebra libraries,
allowing for strong performance and significantly less programming by
The initial release of PLAPACK is due on March 20, 1997, at
which time I'll attempt to supply further details.
The documentation is contained within a book recently published
by the MIT Press and, to a lesser extent, within some reports
and papers available at the site.
- A programming language framework
including a tiny language with a simple syntax wherein most advanced
features can be written in the language itself as modules.
The key features include:
- a full-featured and efficient programming language equivalent to
C++ without the extra baggage;
- a modern logical programming language;
- a scripting language in which small applications can be written
in a very few lines and tested with an integrated debugger;
- a language suitable for very large applications due to the
extensive nature of the module concept and because a library or module
can check the consistency and dynamically rewrite the programs that
- everything is an object including functions and data types;
- meta programming enables lazy evaluation where needed; and
- a dynamic compiler that checks the details of the machine on
which its running.
- A set of libraries for writing games and other realtime interactive
applications that are portable across a wide range of hardware and
The components of PLIB are:
- the Picoscopic User Interface (PUI) library, a set of
C++ classes that allow programs written in
GLUT and OpenGL to
create buttons, sliders, menus and the other pieces of GUIs;
- the Sound Library (SL), for playing, mixing and modifying sound
samples in realtime;
- the Simple Geometry (SG) library, a set of matrix, quaternion and
vector math functions;
- the Simple Scene Graph (SSG) library, a simple and low impact
scene graph C++ API on top of
- the Joystick (JS) library, a portable interface for joysticks; and
- a Font and Text (FNT) library that allows PUI programs to
produce text using texture maps rather than bitmaps.
- Persistent Linda is a programming environment for writing
fault-tolerant distributed/parallel program that run on networks
on workstations. PLinda is a set of extensions to the Linda parallel
programming model, and PLinda/C++ and PLinda/Fortran are implementations
combined with those sequential languages.
The key design issues of PLinda are:
A source code distribution of PLinda is available. Installation
requires GCC 2.6.3 or above and Tcl/Tk 3.6 or higher.
- fault tolerance capabilities wherein applications can be built
such that they will survive failure during execution and finish
their appointed tasks;
- effective use of workstations wherein the PLinda parallel virtual
shared memory machine, whose processors are idle workstations, uses
only those processors that are idle, adding and subtracting those
that become idle or busy;
- high performance wherein fault tolerance can be customized for
each application such that performance is maximized.
- Programming Language/Microcomputers was created
in 1972 as a very low level language incorporating ideas from
PL/I, ALGOL and XPL. It was originally the implementation language
Versions of the language included PL/M-80, PL/M-86 and PL/M-286.
- The source code for the Intel PL/M-80 compiler.
This is written in Fortran 66.
- A PL/M-286 to C converter.
- A package for creating graphical data displays for web pages, paper
reports, posters, slides and interactive use.
The features include:
- script-driven input that can be automated;
- creating graphs from flat ASCII or spreadsheet datasets that can
include numbers and text as well as dataes and times in a wide
variety of notations;
- built-in capabilities to compute frequency distributions, cross-tabs,
medians, quartiles and curve fits;
- many different plot types including line plots, filled line plots,
range sweeps, pie graphs, horizontal and vertical bar graphs,
time lines, bar proportions, 1- and 2-D scatter plots,
box plots (range bars);
- table rendering and table-based graphs via the additional
- error bars; and
- legends and annotations.
- A fast multi-purpose plotting program for X-windows. It allows
the construction of 2-D line and scatter plots, contour plots,
3-D surface, line and scatter plots as well as vector plots.
It should install reasonably easily on any platform running
- A general purpose, interactive, command driven, scientific
The features of PlotPlus include:
support for multiple output devices including X11, PostScript,
GIF, MPEG, and HDF animation files;
a powerful and flexible scripting language;
support for multiple input formats including ASCII, binary, and
integration with nccalc for NetCDF reading, writing, and
generation of MPEG animations using the Berkeley MPEG-1 software encoder;
several data display options including X-Y line plots, contour plots, and
color area fill;
several map projections including Mercator, Polar Stereographic, and
linear, log and time axes;
colored labels, plot lines, and contour lines; and more.
A source code distribution of PlotPlus is available. It
is written in Fortran and C and can be compiled and used on
most UNIX platforms.
It is documented in a user's manual available in
See also the EPIC package which uses
this for plotting.
- The AthenaTools Plotter Widget Set is a set of widgets to add
graphs to X programs. It provides many of the features needed
to embed a scientific or business graph into another program.
This set is based on Xlib and
Xt and is intended to be used with other
widget sets based on the same, e.g. Xaw
It is not 3-D and cannot do pie charts or other non-XY type
The features of the widget set include:
- X-Y plots for scientific graphics;
- line and bar plots for business-style graphics;
- the automatic or manual scanning of axis values and the automatic
selection of tic marks;
- flexible text facilities including mathematical symbols,
sub- and super-scripts, font changes, etc.;
- an unlimited amount of plots on each graph with each independently
- generation of EPS which closely matches screen output;
- the use of either linear or logarithmic axes labeled at arbitrary
points with arbitrary strings;
- flexible axis handling with up to four axes on each graph; and
- a fast update mode which can quickly redraw rapidly changing data;
easy access to application data stored in an array of
The source code of the Plotter library is available.
It is written in C and can be compiled on most generic
UNIX/X11 platforms via the Imakefile in the distribution.
Demonstration programs are included for both
Motif and Xaw.
The library is well documented in both man pages and
a PostScript user's guide included in the distribution.
- The GNU plotting utilities
are a library and a collection of programs for plotting 2-D scientific data.
The libraries are:
The library can produce output in X11, SVG, PNG, PNM, pseudo-GIF,
WebCGM, Illustrator, PostScript, PCL 5, HP-GL/2, Fig, ReGIS,
Tektronix or GNU Metafile formats.
- libplot, a C/C++ function library for device-independent
2-D vector graphics that is compatible but more powerful than the
traditional UNIX libplot library; and
- libplotter, a C++ class library that provides an
object-oriented interface to the functionality of libplot.
Plotutils contains several command line programs for accomplishing
various tasks including:
- graph, plots 2-D datasets or data streams in real time and
produces output in several different formats;
- plot, translates GNU metafile format to other formats;
- tek2plot, translates legacy Tektronix data to other formats;
- pic2plot, for translating the pic language to other formats;
- plotfont, for displaying character maps of available fonts;
- spline, performs spline interpolation of data; and
- ode, numerically integrates a system of one or more ODEs.
A source code version of plotutils is available. It is written
in C and can be installed on a wide variety of platforms using
the configure file included in the distribution.
Its use is documented in a user's manual included in
- A Perl module for the C++
libplotter component of
- A Python module that implements the
libplot part of the plotutils
package. This was created using SWIG.
- A library of C functions that are useful for making scientific
plots from a program written in C or Fortran. PLplot can be used
to create x-y, log, semilog, loglog, contour, and mesh plots as well
as bar and pie charts. The kernel of PLplot was based on
PGPLOT but the code was
not derived from it. The authors have designed it to be an
inexpensive and portable way to create scientific graphics.
The capabilities of PLplot include:
It also has an interactive
driver written in
Tcl/Tk that can be used
to manipulate a graph, e.g. zooming, panning, scaling, orienting,
changing colors, etc. PLplot has bindings that allow it to be
used in both Fortran and C programs.
zoom, pan, scale, orient, and change colors
on the same page with multiple lines on each. A wide variety of
line styles, widths, colors and fill patterns are available as well
as many characters in an extended character set. Many different
output device drivers are available, including a portable metafile
format and renderer. A Tcl/Tk
GUI is currently being developed.
- placing multiple graphics on the
same page with multiple lines on each;
- support for many different
types of line styles, widths and colors;
- many kinds of area
- a generous choice of fonts and font sizes
including Greek letters and mathematical symbols; and
- drivers for a wide number of output devices including X Windows,
Tektronix, PostScript, etc.
The source code is available and has been compiled on generic
UNIX platforms as well as on VMS, Amiga, MS-DOS and NeXT platforms.
There is a user's and reference
guide available in PostScript format that describes how to use
the package and details the individual subroutines, although
the most recent version lags behind the software itself.
- A Python module that implements the functionality
of the PLplot graphics package.
This also requires NumPy.
- A package for solving an elliptic partial differential
equation in general regions of the plane. It features adaptive local mesh
refinement, multigrid iteration, and a pseudo-arclength continuation option for
parameter dependencies. The package includes an initial mesh generator and
several graphics packages.
The source code is contained in several files. Both single and double
precision versions are provided in directories single and double respectively.
The file pltmg.f contains the majority of the routines, which are machine
independent and should compile on a wide variety of computers (Apple, Cray,
DEC, SGI, Sun, IBM) with no modification. The file machdep.f contains four
machine dependent routines, namely PLTUTL, PLINE, PFILL, and TIMER; these
routines may have to be modified for your local environment. The provided
source code is set up to use graphics drivers for an X-Window System color
workstation (xgraph.c), and a PostScript driven laser printer (psgraph.f).
Graphics drivers for Sunview, MacIntosh, Silicon Graphics, and IBM PC
have also been implemented.
The documentation is contained in Bank (1996).
- A set of specifications, often abbreviated PnP,
which allow a compatible device to be
recognized and its hardware resource requirements examined
or changed, with the hardware resource requirements being
DMA channels, I/O ports, IRQ signals, and memory addresses.
Kernel patches are available (in various states of usefulness)
to enable such things to be done by Linux.
There is also a package called
isapnptools which allows
PnP devices to be configured on a Linux machine.
- See under Netscape.
- Web browser implemented using
Tcl/Tk. This will parse
HTML up to a subset of HTML V3.0 in its
Alpha incarnation, and is planned to be fully 3.0 compliant.
Plume will download and execute Tcl scripts a.k.a. applets
in a manner similar to the
This used to be called SurfIt.
- The Parallel Library for Unstructured Mesh
Problems supports the transparent use of parallel machines
for the solution of PDEs on unstructured, adaptive
finite element meshes.
PLUMP exploits the common denominators in such problems, provides
key kernels such as matrix-vector product and preconditioners for a
wide range of iterative solvers, and supports the parallelization
of this class of applications in a clean and concise manner.
The routines in the PLUMP library are divided into several
categories based on functionality including:
- routines for performing the initialization of the PLUMP data
structures for the vertex mapping, the global matrix and the set of
- routines for vertex operations including insertion, deletion
and gathering information;
- routines for vector operations including initializing, vector
norms and scalar products;
- routines for element operations including insertion, deletion and
- routines for performing operations on the global matrix;
- routines for solving the resulting linear systems;
- routines for applying the various types of boundary conditions.
A source code distribution of PLUMP is available. It is implemented
in C and Fortran 77 using
the MPI library and is freely available for
It is documented in a user's guide in PostScript format.
- A Web-based search engine that remembers which pages its users
like or don't like and uses the information to return filtered
Pluribus constructs a single coherent list of results from the
opinions of all users.
A Pluribus query is submitted to Metacrawler, a front-end that
combines results from many search engines. From these results
a score is assigned to each page that consists of the
score assigned by Metacrawler, a score based on how many votes
(i.e. hits) a page gets, and a score based on the number of
times a page should have been selected (i.e. points are
subtracted if a page at the top of the list is not selected).
This is a PHP program that also
- Program Linkage by Universal Software-Interfaces
provides a transparent communication mechanism among vendor specific
and standard parallel message passing environments.
Existing applications can make use of PLUS via just four commands to
allow interprocess communication with other programming environments, e.g.
an MPI program on a supercomputer can communicate
via PLUS with a C/PVM code on a parallel network
of UNIX workstations.
The PLUS environment provides:
A source code distribution of PLUS is available. It consists of a
set of daemons and a C library to be linked to the application
source code. The current (2/99) version supports
Documentation includes a technical report and a slide presentation.
- transparent communication among the most popular MIMD programming
- a flexible interface to resource management systems;
- inter-system communication with only a few changes to source code; and
- the adaptive startup of PLUS daemons with increasing communication
- A toolkit for Fortran programmers.
The Linux version is somewhat limited in functionality but free for
academic and commercial evaluation use. It does not have any time
or size restrictions and contains all of the restructuring and static
analysis capabilities of the standard version. It can handle
F77 and most common extensions, including all of VAX Fortran.
Excluded features include coverage and dynamic analysis, clutter
removal, F77-F90 translation, variable renaming, complexity
metrics, and SQL and ICETRAN parsers.
- A general purpose 3-D graphics library designed for efficiency,
rendering quality, and overall ease of use.
The features of version 1.1 include:
- 8 bpp palettized rasterizers (for triangles only);
- an Open Rasterizing Architecture (ORA) which makes it easy to
use other rasterizers with Plush or write your own wrappers
for hardware acceleration;
- several fill modes including solid, translucent, affine environment
mapped, perspective environment mapped, affine texture mapped,
perspective texture mapped, and others;
- several shade modes including Lambert, Gouraud, Phong, Distance
Gouraud, and distance flat shading;
- hidden surface removal;
- full 3-D frustrum clipping by polygon splitting with automatic
- an unlimited number of cameras with full camera control (i.e.
six degrees of freedom);
- an unlimited number of lights;
- point or directional lights;
- support for precalculated lighting;
- handling of materials by automatic palette mapping and management;
- a PCX texture reader;
- automatic texture rescaling and palette optimization;
- an nth dimensional spline interpolator for smooth motion;
- tension, continuity and bias controls;
- generation of primitive objects; and
- readers for 3DS, COB, and JAW meshes.
A source code distribution of Plush is available as are
binaries for several platforms including Linux Intel.
The code is written in ANSI C and can be compiled on a wide
variety of platforms.
Several example programs are available.
- A reference implementation of the
Internet Key Exchange (IKE) protocol, the
Internet Security Association and Key Management Protocol
(ISAKMP), and the Internet IP Security
Domain of Interpretation (DOI).
- The Prolog/Mali system is
a compiler for the logic programming language LambdaProlog, an
extension of standard Prolog in which terms are simply
typed lambda-terms. This can be used in the same types of
applications as standard Prolog, and
is especially good for applications where the scoping of
variables is important, e.g. theorem proving, implementation of
type systems, formal transformation of structured
The PM system is a compiler writer in PM which produces
C code, with the execution system using Mali, an abstract
memory for representing terms with efficient space management.
The PM systems is available either as source code or as
a binary for Sun SunOS, HP-UX, or Linux Intel platforms.
The distribution consists of the compiler, the libraries,
a user's manual in PostScript format, and some examples.
- A project manager offering a simple way to browse through a collection
of source files that constitute a project.
The capabilities currently (11/98) include adding new or existing
elements to the source tree and cutting/copying/pasting between branches.
This relies on NEdit for its editing
Source code and Linux binary distributions are available, with the
former requiring the FLTK widget set for
- PMD (F90)
- The Parallel Multi-Domain decomposition package is
a set of Fortran 90 modules implementing
a parallel non-overlapping domain decomposition method based on the
dual-Schur complement. The Schur matrix is built using a
parallel influence matrix technique, and a 1-D domain decomposition
is currently (3/99) used for both 1- and 2-D problems.
The interface problem can be solved using either a direct or iterative
A source code distribution is available. It is built on top of
MPI and will work on most implementations of
- Parallel Molecular Dynamics is a scalable, parallel
program for efficiently simulating the molecular dynamics of
It uses the Greengard/Rokhlin Fast Multiple Algorithm to allow
the simulation of very large systems without sacrificing long-range
The features of PMD include:
See Windemuth (1995).
- a distance class algorithm that reduces calculation time to make
full-range calculations faster than conventional cutoff methods;
- scalability, i.e. arbitrarily large systems can be simulated
as long as sufficient processing nodes are available; and
- a choice of parallel processing interfaces, i.e.
- Pattern-Matching Multicast is a combination of
local control architecture and communication protocols that allow
media agents, controllers, and auxiliary applications such as media
recorders and management proxies to be tied together into a single
This is basically a replicator that connects media agents like
NeVoT and isc on
systems that don't support multicast.
Each conference can be shared among several controllers and each media
can be handled by one or more indpendent media agents.
The communicating applications disseminate state and control
information via a replicator which limits the distribution of messages
based on the expressed interest of other applications. Thus it implements
an application-level, receiver-driven local multicast.
Distributions are available for several platforms including Linux Intel.
Documentation is contained in a couple of technical reports.
- A portable implementation of the
PMPIO is a tool for refining the MPI-2 I/O chapter specification
and a base for developing vendor implementations of MPI-2.
The interim beta release is not intended for production use.
The current (5/97) version of PMPIO features:
Additional features which may be included but aren't in the
current (5/97) beta release are:
asynchronous I/O, atomicity operations,
shared file pointers,
profiling, support for files stored on NFS file systems,
support for MPICH,
and support for PMPIO ALPHA based codes.
- full support for arbitrary filetypes (data distributions),
- MPI compatible datatype constructors for common distributions,
- collective I/O operations optimized via collective buffering,
- 64 bit support,
- support for info objects cb_nodes and
- error handling, and
- full C and Fortran 77 interfaces.
- PM2 High Perf
- The Parallel Multithreaded Machine is a portable
multithreaded environment providing execution support for highly
parallel applications. The PM2 programming model is based on threads
and the Lightweight Remote Procedure Call (LRPC) mechanism, and it
is distinguished by such features as a priority driven scheduling
policy, thread migration mechanisms, and the ability to permit
easy development of various load balancing policies.
It is built on top of a communication package (currently (2/98)
TCP, or BIP) and a
process library called MARCEL.
MARCEL is a user-level thread package designed to provide a large
subset of the POSIX standard thread interface
primitives along with some additional features, e.g. dynamic stacks
The PM2 environment provides a computing model based on lightweight
processes that allows the exploitation of heterogeneous configurations.
Remote functionalities (e.g. remote creation, etc.) were added to
a standard threads package to provide special functionalities for
parallel computing (e.g. dynamic stack resizing, thread migration,
stack caching, etc.).
It consists of an LRPC mechanism that forks a remote thread to execute
a specified service. Three types of LPRCs are available.
A synchronous LRPC is equivalent to a classical
RPC except that code is execute by a remote thread in another process.
It is blocked until it gets back a result and thus can't initiate further
An asynchronous LRPC is a method of efficiently initiating remote
threads since it involves only sending a message and no waiting for
results to return.
A deferred waiting LRPC decomposes the LRPC in two steps: (1) an LRP
Call (asynchronous creation of a remote thread) and (2) an LRP Wait (waiting
for results). This allows the generation of real parallelism since
several LRP Calls can be triggered without waiting for results to return.
A source code distribution of PM2 is available. It can be used
on several platforms including Alpha OSF-1, Sun Solaris and SunOS,
Linux Intel, SGI IRIX, and PowerPC/AIX.
The documentation is currently available only in French although
English versions are promised.
- Python megawidgets is a framework for
building high-level compound widgets in Python
using the Tk graphics library.
It provides a method for obtaining a consistent look and feel between
graphical applications and is highly configurable.
Pmw consists of a set of base classes and a library of flexible
and extensible megawidgets built on the base classes, e.g.
ButtonBox, ComboBox, MessageDialog, etc.
Other features include:
a lazy importer/dynamic loader which is automatically invoked when
Pmw is first imported which gives unified access to all Pmw classes
and speeds up loading time;
complete documentation of megawidget options, methods, and components;
a test framework and tests for both the Tkinter
module and all the Pmw widgets;
a demo of all the widgets; and
an interface to the BLT busy, graph and vector
A source code version of Pmw is available. It is written in
Tk and Python and also requires the
Full documentation is included in the package and is also
Up: Linux Software Encyclopedia