Next: Pn-Pz Up: Linux Software Encyclopedia Previous: On-Oz Contents

Pa-Pm

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 corpus linguistics. 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 similarities;

discrim, which computes the discrimination value of words in text files;

bigrams, which computes the approximate mutual information for bigrams;

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 cross-referenced file;

arg-expand, which expands a range, e.g. a,c-f,..., to a,c,d,e,f,...'

arfftosvd, which converts an arff file to the input format of svdinterface;

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 negative classes;

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.
[http://pi0959.kub.nl:2080/Paai/Publiek/]
Pacco: Pavia's Active Component Compound Objects is an object-based scripting language 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 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.

A generic Pacco viewer (gpv) has been written using the library and is additionally available.
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 the distribution.
[http://iride.unipv.it/pacco/Index.html]
Pack: 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.
[http://www.linuxos.org/Pack.html]
package: 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.
[http://www.cus.umist.ac.uk/~ivarch/linux/package/]
packaging tools: Packaging or archiving and related software include:

Alien;

compression/archiving packages;

gbuild;

KPackViewer;

morepkgtools; and

RPM.
packmon: 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.
[http://www.ers.ibm.com/~davy/software/packmon.html]
PACT: 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 portable applications,

rapid prototyping,

portable and efficient binary data handling,

a graphics system interface to several systems (X Windows, QuickDraw, DOS, PostScript, and CGM),

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 the differences;

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 system;

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.
[http://www.llnl.gov/def_sci/pact/pact_homepage.html]
PADE: 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 machine.
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 development host;

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 and Tcl/Tk. The documention consists of user's and installation manuals available in HTML and PostScript format.
[http://www.itl.nist.gov/div895/pade/]
PadFEM: 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 solvers. 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 release.
[http://www.uni-paderborn.de/cs/padfem/]
Pad++: 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 through them.
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.
[http://www.cs.umd.edu/hcil/pad++/]
PADRE: 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.
[http://acts.nersc.gov/padre/main.html]
paintlib: 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 are available. A source code distribution is available.
[http://user.cs.tu-berlin.de/~uzadow/paintlib/]
paleotec: 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 some orogenies.
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).
[ftp://element.ess.ucla.edu/paleotec/]
Paloma: 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 intermixed. 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.
[http://www.cs.fsu.edu/~rose/paloma/paloma.html]
PAM: 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 at runtime. 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 smartcards, etc.
Some of the modules to be found in the PAM source distribution include:

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 authentication;

pam_rhosts, for rhost verification;

pam_skey, for S/Key authentication; and

pam_time, for authorization based on time of login.

The December 1997 issue of the Linux Journal contains an article about PAMs.
[http://www.us.kernel.org/pub/linux/libs/pam/]
PAMELA: 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 threads. 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.
[ftp://dutepp0.et.tudelft.nl/pub/gemund]
[http://dutepp0.et.tudelft.nl/~gemund/Pamela/pamela.html]
PAML: The Phylogenetic Analysis by Maximum Likelihood package is for the phylogenetic analyses of DNA or 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 rates, etc.;

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 distances, etc.

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.
[http://abacus.gene.ucl.ac.uk/ziheng/paml.html]
PANDA: 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).
[http://drl.cs.uiuc.edu/panda/]
Pandora: 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.
[http://faculty.ed.umuc.edu/pandora/index.html]
Pango: An open source framework for the layout and rendering of internationalized text. 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.
[http://www.pango.org/]
Panorama: 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 formats. 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 added;

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.
[http://www.gnu.org/software/panorama/panorama.html]
Paos: 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.
[http://www.cs.colorado.edu/~carlosm/software.html]
PAPERS: 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 modes.
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 Linux.
[http://garage.ecn.purdue.edu/~papers/]
PAPyRUS: 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).
[http://or.mime.univ-paris8.fr/~loscar/Papyrus/
papyrus_eng.html]
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.
[http://www.nyx.net/~dminer/pvm/]
Parallaxis: 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 hardware. 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 image processing.
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).
[http://www.ee.uwa.edu.au/~braunl/parallaxis/]
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 the community.
[http://yara.ecn.purdue.edu/~pplinux/]
parallel/concurrent programming: The use of several machines or processors to perform computational tasks. The January 1988 issue of the Linux Journal contains many articles on parallel processing with Linux.
Related and interesting sites include:

National HPCC Software Exchange
http://www.nhse.org/

Parascope
http://computer.org/parascope/

Concurrent Systems
http://www.comlab.ox.ac.uk/archive/concurrent.html

Parallel Computing Research Groups
http://www.cs.cmu.edu/~scandal/research-groups.html

Parallel Tools Projects
http://www.ptools.org/projects.world.html

Internet Parallel Computing Archive
http://www.hensa.ac.uk/parallel/

Object-Oriented Parallel Programming Research
http://www.osc.edu/~trey/oopp.html

Hardware-related entries include:

PAPERS,

Languages developed for parallel programming or with parallel programming capabilities include:

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 distributed applications;

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 processes;

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, data-parallel language;

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 transformational programming;

uC++, an object-oriented language with high-level concurrency;

UFO, a language that unites functional and object-oriented techniques to ease the tasks of developing programs for parallel machines;

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 parallel computation;

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 parallel programming;

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 synchronization;

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, adaptive meshes;

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:

aCe,

APACHE,

Arjuna,

Calypso,

CHARM,

clsh,

CODE,

Condor,

Converse,

DOGMA,

DSC,

Globus,

GLU,

GLUnix,

HPVM,

Mentat,

PADE,

PRM,

Proteus,

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 passing model.

Miscellaneous tools related to parallel programming include:

ADAPTOR,

AIMS,

bWatch, a GUI showing load and memory statistics for each node of a cluster;

DFN-RPC,

dmake,

dsh,

esep,

Limes,

MAD,

Maisie,

Nascent,

OMIS,

PAMELA,

ppmake,

PRNGlib, several pseudo-random number generators for shared or distributed memory parallel architectures;

pWEB,

SCore,

SHORE,

TAU,

Software related to parallel numerical methods or scientific computation, i.e. applications, include:

A++/P++,

Aztec,

BILUM,

BLACS,

BlockSolve,

BTN,

CCP5,

COSMICS,

CuPit,

DAGH,

DGENESIS,

DOUG,

EGO,

FEAT,

fsolver,

GALOPPS,

KeLP,

LASSAP,

LPARX,

Moldy,

MOM,

MPI-RGL,

MPQC,

MSG,

NAMD,

NWChem,

Omega Project,

PACT,

PARASOL,

ParMETIS,

ParPre,

Parssim1, an aquifer or reservoir simulator for incompressible, single phase flow and reactive transport of subsurface fluids through a heterogeneous, porous medium;

PAWS,

PBLAS,

PCCM,

PCG,

PeIGS,

PETSc,

PGAPack,

PIM,

PLAPACK,

PMD, for simulating the dynamics of biological macromolecules;

POOMA,

pPCx,

P-SPARSLIB,

PSTSWM,

QCDMPI,

RAM,

RSL,

sB-BLAS,

ScaLAPACK,

SEA,

SILOON,

SPRNG,

SYISDA,

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 clusters;

Galley, a parallel file system;

PANDA, a parallel I/O system for workstation clusters;

PFSLib,

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. See Almasi and Gottlieb (1994), Andre et al. (1985), Barbosa (1996), Carriero and Gelerntner (1990), Chandy and Misra (1988), Codenotti and Leoncini (1993), Dongarra and Tourancheau (1993), Foster (1995), Geist et al. (1994), Gibbons and Rytter (1990), Greenlaw et al. (1995), Hulle et al. (1994), Kowalik (1985), Gelernter et al. (1990), Gropp et al. (1994), Jamieson et al. (1987), Kuck (1996), Kumar et al. (1994), Lakshmivarahan and Dhall (1994), Nicolau et al. (1991), Pardalos (1999), Perrott (1987), Reed and Fujimoto (1987), Sabot (1995), Shiva (1996), Simon (1992), Skillicorn (1995), Smith (1993), Tel (1995), Wilson (1995), Wilson and Lu (1996), Wolfe (1996) and Zima and Chapman (1991).
Paranoia: 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, and Pascal.
[http://www.netlib.org/paranoia/]
Para++: 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 MPI.
[http://www.loria.fr/para++/parapp.html]
PARASOL: 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 environment TRAPPER, to establish continuous library support, and to evaluate the library.
[http://www.genias.de/projects/parasol/index.html]
PARI-GP: 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 PariPython.
[ftp://megrez.math.u-bordeaux.fr/pub/pari/]
[http://hasse.mathematik.tu-muenchen.de/ntsw/pari/Welcome]
ParkBench: 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 a system;

POLY3, which assesses the severity of the communication bottleneck; and

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:

matrix kernel benchmarks including dense matrix multiply, transpose, dense LU factorization with partial pivoting, QR decomposition and matrix tridiagonalization;

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 compact application benchmarks include codes representative of the fields in which parallel computers are actually used. These include:

PSTSWM, a parallel spectral transform shallow water model; and

three computational fluid dynamics codes called the NPB-CFD codes.

The last benchmark level consists of an HPF compiler benchmark suite.
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.
[http://www.netlib.org/parkbench/]
ParMETIS: 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 partitioning scheme. The features of ParMETIS include:

quick computation of high quality partitions of very large graphs,

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.
[http://www.cs.umn.edu/~karypis/metis/]
PARPACK: See ARPACK.
parpd: A proxy ARP daemon for dealing with hosts having out of date implementations of the Internet protocols that don't understand IP subnetting. 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.
[http://www.ers.ibm.com/~davy/software/parpd.html]
ParPre: 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 ScaLAPACK.
[http://www.math.ucla.edu/~eijkhout/parpre.html]
PARSEC: The PARallel Simulation Environment for Complex systems is a C-based discrete-event simulation language that adopts the process interaction approach to discrete-event simulation. 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 conservative protocols. 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 Linux Intel. A user's manual is available in PostScript and PDF formats.
[http://may.cs.ucla.edu/projects/parsec/]
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 Bison, byacc, LLgen, PRECCX, and RDP. See also the compiler construction tools, various package which contain parser generators as part of a suite of tools.
parsetools: 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 lines;

pgen, provides a low level interface into Python's built-in parser; and

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.

[ftp://archaeopteryx.com/pub/parsetools/]
Parssim1: 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:

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 source code distribution of this Fortran package is available. It is documented in a user's guide in PostScript format.
[http://www.ticam.utexas.edu/~arbogast/parssim/]
parted: 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.
[http://www.gnu.org/software/parted/]
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 method include:

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.

See Jones et al. (1993) and Danvy et al. (1996).
Available partial evaluation tools include:

C-Mix, for C programs;

Schism, for Scheme programs;

Similix, for Scheme programs.
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.
[http://www.amara.com/papers/nbody.html]
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 solid shapes. 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.

[http://www.cs.unc.edu/~davemc/Particle/]
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.
[http://partimage.sourceforge.net/]
PAS: The Perl Application Server is a set of nested APIs for writing Web-based intranets in Perl and Java. Most of the APIs are wrappers around third-party modules. The APIs include:

Templates, a wrapper around Text::Template and Text::BasicTemplate;

DB, a wrapper around DBI::DBD;

a Java/Perl RPC API;

an XML/XSL API; and

an EJB API.

A source code distribution is available, although documentation is currently (2/99) a bit sketchy.
[http://www.pault.com/Pas/]
Pascal: 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 data structures. 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 Mallozzi (1989).
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.
Pash: A full screen shell for UNIX that is not unlike Norton Commander. The features of Pash include:

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 hierarchies.

Source and binary distributions are available for Linux platforms.
[http://home.inreach.com/xpierre/pash/]
PASSCAL: 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 file;

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 RefTek;

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 pdata stream;

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:

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 traces;

clockview, which provides X11 display of external clock phase errors;

logview, a GUI providing useful graphs of information in logfiles;

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.

Event association programs are:

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.

Miscellaneous programs include:

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 statements.

Several other programs are also available for dealing with SEGY and mini-SEED data.
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.
[http://www.ldeo.columbia.edu/Passcal/]
Pâté: 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.
[http://www.cs.duke.edu/~anya/]
Pathetic Writer: An X Window-based word processor for Linux which uses Scheme as an extension language. See also the same author's SIAG and Egon Animator packages.
[http://www.edu.stockholm.se/pw/]
Pavuk: A program for mirroring the contents of Web documents via HTTP, FTP, Goper and HTTPS (SSL) servers. The features include:

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.

A source code distribution is available.
[http://www.idata.sk/~ondrej/pavuk/]
PAWS: 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.
[http://www.acl.lanl.gov/PAWS/]
PBLAS: 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 the ScaLAPACK subroutine library.
[http://www.netlib.org/scalapack/html/pblas_qref.html]
PBM: See Pbmplus.
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 anymaps.

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 repositories. Each tool in the package is documented in a separate man page. A newer version of this with some additional capabilities is Netpbm.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/graphics/convert/]
[http://www.acme.com/]
Pcb: 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 constructed include:

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:

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 source code distribution of this C/X11 package is available. It is documented in a user's manual available in the usual formats.
[http://bach.ece.jhu.edu/~haceaton/pcb/]
[ftp://ftp.uni-ulm.de/pub/pcb/mirror/]
PCCM: A Parallel version of the NCAR Community Climate Model implemented for MIMD massively parallel computers using a message passing programming paradigm. 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 boundary conditions. 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 PVM package. The source code for PCCM is available. It is written in Fortran 77 and documented in a user's guide available in PostScript format.
[http://www.epm.ornl.gov/chammp/pccm2.1/index.html]
PCCTS: The Purdue Compiler Construction Tool Set has been renamed ANTLR.
PCFEAP: 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).
[http://www.ce.berkeley.edu/~rlt/]
PCG: 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 source code. 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).
[http://www.cfdlab.ae.utexas.edu/pcg/]
[http://www.netlib.org/linalg/]
PCHIP: 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:

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 routines used to evaluate, differentiate, or integrate the resulting functions include:

CHFEV, to evaluate a single cubic Hermite function at an array of points;

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.

The routine PCHMC is a monotonicity checker and CHFIV, CHFMC, PCHCE, PCHCI, PCHCS, PCHDF, PCHST, and PCHSW are internal routines to perform various tasks.
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).
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
PCI: Later. Gripe at me if later hasn't yet arrived and you think it should.
pciutils: A set of utilities for dealing with the PCI bus in Linux include:

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 configuration registers.

A source code distribution is available.
[http://atrey.karlin.mff.cuni.cz/~mj/pciutils.html]
PCL: 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:

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.

A source code distribution of PCL is available. It is free for non-commercial uses and is documented in a user's guide.
: [http://www.fz-juelich.de/zam/PCL/]
PCMCIA: The Personal Computer Memory Card International Association is 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 Card Services.
[http://www.pc-card.com/]
PCNFSD: 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 server. 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.
[http://sunsite.unc.edu/pub/Linux/system/network/sunacm/Other/pcnfsd/]
[http://rufus.w3.org/linux/RPM/pcnfsd.html]
[http://www.cert.org/ftp/tools/pcnfsd/]
PCOMP: 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).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
PCRE: 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.
[ftp://ftp.cus.cam.ac.uk/pub/software/programs/pcre/]
PCthreads: A multithreading library for Linux-based Intel systems which is based on the POSIX 1003.1 standard for threads. 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.
[http://www.aa.net/~mtp/PCthreads.html]
PCx: 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.
[http://www.mcs.anl.gov/home/otc/Library/PCx/]
PD: Pure Data is an object-oriented graphical programming language for computer music in which objects are patched together with lines to form a running program. The program can be changed at runtime for easy experimentation. Subroutines are also available for building libraries of PD objects.
[http://gige.epy.co.at/pd/pd.html]
[http://man104nfs.ucsd.edu/~mpuckett/software.html]

GEM

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.
[http://www.danks.org/mark/GEM/]
PDDL: A problem specification language developed for the AIPS-98 planning competition. The syntactic features supported include:

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 subgoals; and

management of multiple problems in multiple domains using differing subsets of language features.

The distribution contains a syntax checker, a solution checker, several sample domains, and a user's manual. The package is written in Common Lisp.
[ftp://ftp.cs.yale.edu/pub/mcdermott/software/]

pddlparser

A parser for strict PDDL.
[http://www.dur.ac.uk/~dcs0www/research/stanstuff/planpage.html]
PDECOL: See PDELIB.
PDECONT: A Newton-Picard single shooting code.
[http://www.cs.kuleuven.ac.be/~kurt/bifcode.html]
PDELIB: 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 PDETWO.
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).
[http://math.nist.gov/cgi-bin/gams-serve/list-package-components/PDELIB.html]
PDETWO: See PDELIB.
PDF: The Portable Document Format is the underlying file format for the Acrobat family of document interchange products created by Adobe (who also created the earlier PostScript 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 Acrobat Reader. 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 xpdf package. Informative sites include the PDF Corner, the PDF Zone, and the Adobe Acrobat site mentioned above.
PDF-related software includes:

ClibPDF

PDFlib

PDFprint

pdftex

pj

retepPDF

xpdf
PDFlib: 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:

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 mosaic.

A source code distribution of this ANSI C package is available. A reference manual describing the API is available in PDF format.
[http://www.pdflib.com/]
PDFprint: 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 xpdf, Ghostscript, HTMLDOC, psutils, poster, libnet and libwww-perl.
[http://www.geocities.com/CapeCanaveral/Hangar/4794/pdfprint/]
pdftex: A program to translate TeX source code files into PDF files.
[http://www.tug.org/applications/pdftex/]
pdksh: 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:

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.

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 Rosenblatt (1993).
[http://www.cs.mun.ca/~michael/pdksh/]
[http://sunsite.unc.edu/pub/Linux/system/shells/]
[ftp://ftp.cs.mun.ca/pub/pdksh/]
PDPE: 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.
[ftp://oalib.njit.edu/pub/PDPE/]
PDP++: 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 representations;

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 platforms. A 250+ page user's manual is available in PostScript format.
[http://www.cnbc.cmu.edu/PDP++/]
pdq: A flexible printing subsystem designed to replace the lp* utilities. 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 becomes available. 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.

[http://feynman.tam.uiuc.edu/pdq/]
PDT: 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:

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.

Four applications have been developed using the DUCTAPE 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 trees; and

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 languages.
[http://www.cs.uoregon.edu/research/paracomp/pdtoolkit/]
PEAKFQ: 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 available. The primary documentation is contained within Kirby (1981). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/peakfq.html]
[http://www.geogr.uni-jena.de/software/peakfq.html]
PEARL: The Process and Experiment Automatization Realtime Language is a language for real time computations. A binary version of PEARL for Linux Intel platforms is available via this URL, although the documentation is written entirely in German.
[http://www.germany.net/teilnehmer/100,69976/html/en/pearl.html]
PEBLS: 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 comparisons. 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).
[http://www.kdnuggets.com/sift/pebls.html]
[ftp://condor.cs.jhu.edu/pub/pebls/]
PeIGS: A collection of commonly used linear algebra subroutines for computing the eigensystem of the real standard symmetric eigensystem problem Ax= $\lambda$ x and the general symmetric eigensystem problem Ax= $\lambda$ Hx where A and H are dense and real matrices with B positive definite and $\lambda$ 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 and MPI. 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.
[ftp://ftp.pnl.gov/pub/permanent/emsl/]
[http://www.hensa.ac.uk/parallel/applications/numerical/ peigs/index.html]
Penguin: 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.
[http://www.eden.com/~fsg/penguin.html]
[http://src.doc.ic.ac.uk/packages/perl/CPAN/modules/by-module/Penguin/]
Pentium Optimized BLAS: See under BLAS.
PEP: 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:

components for the design of parallel systems by parallel programs, interacting finite automata, process algebra, or high-/low-level Petri nets;

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.

Binary versions of the components of PEP are available for a selection of platforms including Linux Intel. Documentation is available in PostScript format.
[http://theoretica.Informatik.Uni-Oldenburg.DE/~pep/]
PEQMOD: 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 friction. The source code is written in Fortran 77 and a manual is included in TeX format. See Hoskins and Simmons (1975).
[http://www.cgd.ucar.edu/gds/svn/]
PERCEPS: 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.
[http://friga.mer.utexas.edu/mark/perl/perceps/]
Perfs: 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 UDP ports. The features include:

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 source code distribution of this Perl script is available.
[http://www.idiap.ch/~gobry/perfs.html]
PERHOM: 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.
[ftp://elib.zib.de/pub/elib/codelib/perhom/]
PERIOD: 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.
[http://star-www.rl.ac.uk/store/storeapps.html]
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.
[ftp://elib.zib.de/pub/elib/codelib/period/]
Perl: An interpreted scripting language optimized for 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 Eclectic Rubbish 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 out the Perl Institute site, which acts as a coordinating and communication center to connect people, information, ideas and resources.
Useful Perl resources on the Web include:

CPAN
[http://www.perl.com/CPAN]

Perl Institute
[http://www.perl.org/]

Perl FAQ
[http://www.perl.com/perl/faq/index.html]

Perl Mongers
[http://www.pm.org/]

Perl Module Map
[http://www.perl.com/perl/info/cpan_modules.html]

Perl Journal
[http://www.itknowledge.com/tpj/]

Perlmonth
[http://www.perlmonth.com/]

See Christiansen and Torkington (1998), Deep (1996), Descartes and Bunce (2000), Dichter and Pease (1995), Friedl (1997), Lidie (1998), Orwant et al. (1999), Schwartz (1993), Schwartz (1997), Siever et al. (1998), Srinivasan (1997), Stein and MacEacharn (1999), Vromans (1996), Vromans (1998), Wall and Schwartz (1991), Wall et al. (1996), Wallace (1999), Walsh (1999) and Wong (1997).
Software packages written using Perl, which modify or extend Perl, or which require Perl for use or installation include: Apache, Automake, Basis, btng, CGIperl, CHARM, Checkbot, C*, dbedit, Elex, ePerl, EPIC, FastCGI, FIDOGATE, FLpr, FOAM, FTE, FTOOLS, GAGS, gd, Gifmap, GlimpseGate, Gre, gtml, Guile, gwstat, htgrep, htmlpp, html2ps, HyperNews, Jrju, keeper, latexmk, LaTeX2HTML, lbnamed, Perl, libwww-perl, LONI, Ltoh, MacroCALC, Majordomo, MHonArc, mod-perl, MPP, mSQL, MTX, mysql, NAGS, NetCDFPerl, NetForum, Nexus, Perl, Oorange, Penguin, PerlDL, PerlMagick, Perl-PVM, perlSGML, perlTk, PGPERL, pod2ps, premail, pscover, RANDLIB, RIB, RNPL, SDF, sdoc, SPONG, Stow, SWIG, texi2html, troff2html, UCM, udunits, Wafe, WebGlimpse, WebMagick, Webmin, WebOOGL, WML, WODA, wwwtable, wwwstat, Xforms4Perl, Xitami, Yard, and Zlib.
[http://www.perl.com/perl/index.html]
PerlIDL/PDL: 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 concise descriptions;

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 PGPLOT libraries;

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 operations;

PDL::Slatec, an interface to the SLATEC numerical programming library; and

PDL::NetCDF, an interface to the NetCDF data storage library.

[http://pdl.perl.org/]
Perlfect Search: A powerful and customizable site indexing/searching package written in Perl. The features include:

an indexing system that uses a document vector model for accurate results;

internationalization;

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 exclusion;

a fast and lightweight search algorithm for quick results for even large sites;

a fully customizable output layer based on user-defined HTML templates;

multiple page result display with a customizable number of results per page; and

an automatic installation and configuration utility.

A source code distribution is available under the GPL.
[http://www.perlfect.com/freescripts/search/]
perlpp: 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.
[ftp://zot.mesastate.edu/pub/wmacevoy/perlpp/]
Perl-PVM: A Perl extension for the PVM message passing system. This allows the development of applications for real-time and client/server systems.
[http://phobos.nsrc.nus.sg/STAFF/edward/Pvm.html]
perlSGML: 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.
[http://www.oac.uci.edu/indiv/ehood/perlSGML.html]
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.
[http://www.focusresearch.com/gregor/psh/]
perlTk: A collection modules and code that attempt to combine the Tk widget toolkit and Perl 5. 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.
[http://w4.lns.cornell.edu/~pvhp/ptk/ptkFAQ.html]
PerlTools: 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 substitution operations.
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.
[http://psaweb.pisa.otm.it/archweb/develop/software/java/misc/]
[http://www.oroinc.com/]
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: Embperl and Penguin.
PETE: 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 C++ overloading. 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.
[http://www.acl.lanl.gov/pete/]
Petidomo: 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 PostScript format.
[http://www.w3.org/pub/WWW/Daemon/]
PETSc: 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) uses MPI 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 data structures;

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 formats;

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 available. See Balay et al. (1997).
[http://www-fp.mcs.anl.gov/petsc/]
PEX: 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), Gaskins (1992), 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.
[http://www.classicgaming.com/pfauzeh/]
PFE: The Portable Forth Environment is an interactive environment for the development of Forth programs. It is ANS compliant and written in ANSI C.
[http://sunsite.unc.edu/pub/Linux/devel/lang/forth/]
pForth: An ANSI-style Forth designed to be portable across many platforms, with the ``p'' standing for ``portable.'' The features include:

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.

Versions are available for UNIX, PC and Mac platforms. A reference manual is available as well as a Forth tutorial.
[http://www.softsynth.com/pforth/]
p4: 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 PostScript format.
[http://www.netlib.org/p4/]
PFSLib: 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 PVM. and other software. PFSLib was tested and runs on several platforms, including Linux. This software will apparently be absorbed into a newer project called TOOL-SET for PVM, although it is still available as a standalone package.
PFSLib is available as source code. The documentation is contained within some papers and technical reports available in PostScript format.
[http://wwwbode.informatik.tu-muenchen.de/~lamberts/ PFSLib/]
[http://www.hensa.ac.uk/parallel/libraries/communication/pfslib/]
PFTP: 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 or gzip/gunzip);

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:

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 source code distribution is available which can be compiled and used on most UNIX platforms. Documentation is via a man page.
[http://star.trek.org/~pftp/pftp.html]
PGA: A simple testbed for basic explorations of genetic algorithms. Parallel Genetic Algorithms allows multiple populations with periodic migration among them and a range of other options. 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.
[http://www.aic.nrl.navy.mil/galist/src/]
PGAPack: A general-purpose parallel genetic algorithm library. 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 operators; easy integration of hill-climbing heuristics; an easy-to-use interface; full extensibility; 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 PostScript format.
[ftp://info.mcs.anl.gov/pub/pgapack/]
PGCC: 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 BSDI platforms.
[http://www.goof.com/pcg/]
PGM: 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 multiple receivers. 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.
[ftp://ietf.org/internet-drafts/-draft-speakman-pgm-spec-02.txt]
PGML: 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 and PDF. It also contains additional features needed to satisfy the needs of Web applications including:

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.

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.
[http://www.w3.org/TR/1998/NOTE-PGML]
PGP: 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 page interesting. See Garfinkel (1994), Zimmermann (1995a), and Zimmermann (1995b).
[http://www.eff.org/pub/Net_info/Tools/Crypto/PGP/]
[ftp://ftp.ifi.uio.no/pub/pgp/]
[ftp://ftp.funet.fi/pub/crypt/cryptography/pgp/]
[http://thegate.gamers.org/~tony/pgp.html]

kPGPShell/gPGPShell

PGP shells for, respectively, KDE and Gnome.
[http://www.dimensional.com/~cwiegand/linux/gpgpshell.html]

PGPHTML

A Perl script for generating PGP-signed Web pages. There is also another script that returns such pages to their original format.
[http://www.geocities.com/CapeCanaveral/Hangar/4794/pgphtml.html]

PGPlib

A library for generating and manipulating PGP packets without having to run PGP. The functionality includes:

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 source code distribution is available which is documented mostly in a set of man pages.
[http://gd.tuwien.ac.at/privacy/pgp-utils/]
PGPLOT: 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, PPM,, PostScript 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 LaTeX picture 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.
[http://astro.caltech.edu/~tjp/pgplot/]

BUTTON

A package of subroutines for building interactive Fortran programs that can be used to create graphs. This is built on top of PGPLOT.
[http://www.ucm.es/info/Astrof/button/button.html]

pgperl

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.
[http://www.ast.cam.ac.uk/AAO/local/www/kgb/pgperl]

PGXTAL

A collection of Fortran routines designed to enable crystallographic structures and density maps to be created and displayed with PGPLOT. PGXTAL provides a basic toolkit for general 3-D rendering which can also create rendered 2-D scientific graphs.
[http://www.isis.rl.ac.uk/dataanalysis/dsplot/]

PONGO

A Starlink Project application for interactively plotting data. It is written to behave similarly to MONGO but to use PGPLOT as the basic plotting package.
PONGO features include:

interactively reading data from a text file,

performing complicated mathematical manipulations of the data using Fortran-like statements that define the required transformation,

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 available geometries.

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.
[http://star-www.rl.ac.uk/store/storeapps.html]

PPGPLOT

A Python module that provides an interface to the functionality of PGPLOT.
[http://ariadne.di.uoa.gr/ppgplot/]

ptcl

A package that implements PGPLOT functions as Tcl/Tk commands. 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 difficult task.
[ftp://ftp.fornax.usno.navy.mil/dist/ptcl/ptcl.html]

REDucmE

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 and more. This is built using PGPLOT and BUTTON. A source code distribution is available.
[http://www.ucm.es/info/Astrof/reduceme/reduceme.html]

STAP

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.
[http://www.astro.wisc.edu/~han/stap/stap.html]

WIP

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 PGPLOT graphics library package. It was developed by an astronomer for use by astronomers but it has much wider application possibilities.
Salient features of WIP include:

reading 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.
[http://bima.astro.umd.edu/wip]
PGRT-TIE: 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:

the Complex System Simulator (CSS);

the Distributed Rate-Monotonic Scheduler (DRMS);

the Information System Manager (ISM) which collects and preprocesses instrumentation data;

an external data representation (XDR) extension which provides flexible access to the XDR protocol for describing and encoding shareable data among applications;

a low-level visual object (LLVO) class; and

a high-level visual object (HLVO) class.

A source code distribution is available.
[http://www.egr.msu.edu/Pgrt/]
Phantom: 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 threads, 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.
[http://www.apocalypse.org/pub/u/antony/phantom/phantom.html]
PHCPACK: 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.
[ftp://ftp.cs.kuleuven.ac.be/pub/NumAnal-ApplMath/PHC/]
PHIGS: The Programmer's Hierarchical Interactive Graphics System is a programming interface for the development of 3-D graphics applications. This standard has been approved as ANSI X3.144-1988, ISO 9592-1:1989 and FIPS 153.
[http://www-09.nist.gov/div897/ctg/graphics/phigs.htm]
[http://www.iso.ch/cate/d17366.html]

PVT

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.
[http://www-09.nist.gov/div897/ctg/graphics/phigs.htm]
PHiPAC: 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 combinations. The package is documented via some technical reports available in PostScript as well as in a set of man pages.
[http://icsi.berkeley.edu/~bilmes/phipac/]
Phorum: A web-based discussion software package written in PHP. The features include:

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.

This PHP package can use either MySQL or PostgreSQL as a database backend.
[http://www.phorum.org/]
PHOTOM: 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.
[http://star-www.rl.ac.uk/store/storeapps.html]
PhotoSeek: 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.

[http://photoseek.sourceforge.net/]
PHP: A server-side HTML embedded scripting language that lets you write simple scripts in your HTML source code files like JavaScript although PHP/FI is not browser-dependent. 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 Apache module.
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 access monitoring;

a built-in web-based configuration screen to handle access control configuration that allows various restrictions to be placed on files and directories (including password access);

support for several database systems including MySQL and PostgreSQL;

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. See Atkinson (1999), Castagnetto et al. (1999), Hilton and Willis (2000), Lerdorf (2000) and Medinets (1999).
[http://www.vex.net/php/]

PHPGen

A PHP script that automatically generates front-ends to MySQL databases.
[http://www.byggsoft.se/~mikaelu/]

phpEasyMail

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.
[http://www.htmlwizard.net/phpEasyMail/]

phpMyAdmin

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.
[http://www.htmlwizard.net/phpMyAdmin/]

WebTheme

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.
[http://www.thestuff.net/theme/]

Zend

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.
[http://www.zend.com/]
phpGroupWare: A multi-user web-based groupware suite written in PHP that provides an API for developing additional applications. The API features include:

a full object-oriented design;

session management;

a database abstraction supporting MySQL and PostgreSQL;

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 XML parser.

The features of the phpGroupWare framework for application integration include:

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 interface.

Many applications are included in the base phpGroupWare system. These include:

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 attachments;

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.

[http://www.phpgroupware.org/]
PHREEQC: A C program designed to perform a wide variety of aqueous geochemical calculations. PHREEQC is based on an ion-association aqueous model and its capabilities include: 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 PHREEQE include:

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 NETPATH. The primary documentation is contained within Parkhurst (1995).
[http://water.usgs.gov/software/phreeqc.html]
PHRQPITZ: 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 by PHREEQC. The reaction modeling capabilities of PHRQPITZ include: aqueous speciation and mineral saturation index; mineral solubility; 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 series. The primary documentation is contained within Plummer et al. (1988).
[http://water.usgs.gov/software/phrqpitz.html]
phttpd: 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 system resources. 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 threads.
[http://home.signum.se/phttpd/]
PHYLIP: 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 characters. 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 maximum likelihood;

DNAMLK, the same as DNAML but assumes a molecular clock;

RESTML, which estimates by maximum likelihood using restriction sites data;

FITCH, which estimates from distance matrix data under the additive tree model;

KITSCH, which estiamtes from distance matrix data under the ultrametric model;

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:

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 parsimony criteria;

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 data.

The interactive tree manipulation programs include:

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:

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.

The data manipulation and bootstrapping programs are:

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 bootstrap resampling;

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 states.

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.
[http://evolution.genetics.washington.edu/phylip.html]
phylogeny programs: Available packages include:

PHYLIP, a package of programs for inferring phylogenies;

[http://evolution.genetics.washington.edu/phylip/software.html]
PHYSICA: 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 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 Savitzsky-Golay filters;

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 25 parameters;

ellipse fitting;

calculation of parameters for least squares fits using adjustable parameters; and

differentiating or integrating arbitrary expressions.

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.

The graphics capabilities of PHYSICA include:

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.

It is also integrated with the EDGR graphics editor.
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 PostScript format.
[http://www.triumf.ca/compserv.html]
PHYS-TeX: 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.
[http://tug2.cs.umb.edu/ctan/tex-archive/macros/physe/]
PHYZZX: 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.
[http://tug2.cs.umb.edu/ctan/tex-archive/macros/phyzzx/]
PIA: The Program for Information Applications is an Open Source 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 for programming. 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.
[http://www.RiSource.org/PIA/]
PIA: 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 biological information. The tentative alignments are performed using a tree-based combination method which can quickly obtain rough correspondence relationships.
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 been installed. A user's manual is included in PostScript format.
[http://www.icot.or.jp/AITEC/IFS/IFS-abst/093.html]
Picasso: 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.
[ftp://zenon.inria.fr/pub/tk/]
PICL: 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 data graphically.

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 PostScript format.
[http://www.netlib.org/picl/]
[http://www.epm.ornl.gov/picl/index.html]
Pict: 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 programs. 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.
[http://www.cs.indiana.edu/hyplan/pierce/ftp/pict/Html/Pict.html]
[http://www.cs.indiana.edu/ftp/pierce/pict/]
PIDDLE: 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 PDF, PIL, PostScript, OpenGL, Tk, GTK+, wxWindows, Quickdraw and Adobe Illustrator.
[http://piddle.sourceforge.net/]
Pike: 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 multiple inheritance;

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 operations;

Sql, an interface to common SQL databases such as PostgreSQL and MySQL;

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.
[http://pike.idonex.com/]
PIKT: 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:

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.

Other components include:

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 corrective action;

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 runs, etc.;

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, and documentation.
[http://pikt.uchicago.edu/pikt/]
PIL: See under Python.
PIM: 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.
[http://www.mat.ufrgs.br/~rudnei/pim/pim-i.html]
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 administrations traversed. The robustness, flexibility and scaling properties of PIM make it well suited for use with large, heterogeneous internetworks.
[http://netweb.usc.edu/pim/]
Pine: 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 lists;

message attachments via MIME;

folder management commands for creating, listing, or renaming message folders;

access to remote message folders and archives via IMAP;

Internet news support via either NNTP or IMAP; and

aggregate operations such as saving a selected set of messages simultaneously.

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 PostScript format.
[http://www.washington.edu/pine/]
[http://sunsite.unc.edu/pub/Linux/system/mail/mua/]

CryptoPine

A set of scripts for using PGP to encrypt and decrypt messages from inside of Pine.
[http://www.arquired.es/users/dani/linux/]
pingutil: 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 in cron.

[http://www.dystance.net/ping/pingutil/]
PinkPanther: 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 and use. The distribution contains documentation for the package.
[http://documents.cfar.umd.edu/resources/source/ppanther/]
Piologie: 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.
[ftp://ruediger.informatik.uni-tuebingen.de/Piologie/]
[ftp://ftp.informatik.uni-tuebingen.de/pub/CA/software/Piologie/piologie.html]
PIOUS: 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 research.
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 PostScript format.
[http://www.mathcs.emory.edu/Research/Pious.html]
Piper: 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 programming language;

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.

[http://www.bioinformatics.org/piper/]
PIPS: A project to develop a free, open and extensible workbench for automatically analyzing and transforming scientific and signal processing applications. PIPS can be used for many tasks including whole program compilation, reverse engineering, program verification, source-to-source program optimization, and parallelization. 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:

coarse grain parallelization;

expression optimizations;

forward substition;

loop distribution, interchange, normalization, reduction and unrolling;

partial evaluation;

parallelization; and

strip mining.

The available analyses and restructurations include:

array privatization, section privatization and element regions;

call and control flow graphs;

continuation conditions;

dependencies;

memory effects;

preconditions;

program complexity;

reduction detection;

scalar variable privatization;

transformers;

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 X11 interfaces.

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.
[http://www.cri.ensmp.fr:80/pips/]
pipewave: 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 |STAT package. Each program is documented in a separate man page.
[http://www.physiol.ox.ac.uk/~jfc/pipewave.html]
PIPS: The Parallel Information Processing System converts data between the portable image map format (PNM) and the NetCDF format. 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 full use.
[ftp://prep.ai.mit.edu/pub/gnu/]
PISA: 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 crowded regions. 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 files;

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 PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
Pisces: 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 surfaces.
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 PostScript formats.
[http://www.geom.umn.edu/~fjw/pisces/]
PISE: The Pasteur Institute Software Environment is a tool for generating Web interfaces for molecular biology programs. 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.
[http://www-alt.pasteur.fr/~letondal/Pise/]
PITCON: See CONTIN.
PITSA: 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.
[http://lbutler.geo.uni-potsdam.de/service.htm]
Pi3Web: 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 multiple requests;

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.
[http://www.johnroy.com/pi3/]
Pixcon/Anitroll: 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 tasks.
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.
[http://www.radix.net:80/~dunbar/]
pixmap: A pixmap editor for editing, for example, colored icons. The source code is available and should install on generic UNIX/X11 platforms.
[ftp://avahi.inria.fr/pub/pixmap/]
Pizza: 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.
[http://www.cis.unisa.edu.au/~pizza]
[http://www.cs.bell-labs.com/who/wadler/pizza/index.html]
[http://wwwipd.ira.uka.de/ pizza]
[http://www.math.luc.edu/pizza/]
pj: A free, Open Source Java class library for parsing, manipulating and creating Adobe PDF files. The distribution also contains pjscript, a script interpreter for creating and modifying PDF files. This requires JDK 1.1 or greater.
[http://www.etymon.com/pj/]
pk/Roadrunner: This OS project has been renamed from pk to Roadrunner.
pLab: 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:

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.

The library is a set of software components that adhere to the protocol and includes:

high-performance implementations of standard random number generators;

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.

Implementations are available in C++, Smalltalk 80 and Mathematica. Documentation includes a reference manual and several technical reports.
[http://random.mat.sbg.ac.at/team/]
PLAM: ProLog And Modeling is an implementation of an algebraic modeling language in Prolog. 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 available SWI-Prolog. 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 format.
[http://www.mpi-sb.mpg.de:/~barth/plam/plam.html]
PLAN: 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 protocols 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 sample programs. 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 PostScript format.
[http://www.cis.upenn.edu/~switchware/PLAN/]
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 UNIX environment. 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 programs; and 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:

Wily, a mouse-oriented, text-based working environment based largely on Acme;

Sam, a multi-file screen editor with structural regular expressions;

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).

See 9 (1995b) and 9 (1995a).
[http://plan9.bell-labs.com/plan9/]
[http://www.caldo.demon.co.uk/plan9/]
[http://www.ecf.toronto.edu/plan9/]
[http://www.ecf.toronto.edu/plan9/plan9faq.html]
PLAPACK: 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 user.
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.
[http://www.cs.utexas.edu/users/plapack/]
Pliant: 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 use it;

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.

[http://pliant.cams.ehess.fr/]
PLIB: A set of libraries for writing games and other realtime interactive applications that are portable across a wide range of hardware and operating systems. 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 OpenGL;

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.

[http://plib.sourceforge.net/]
PLinda: 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:

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.

A source code distribution of PLinda is available. Installation requires GCC 2.6.3 or above and Tcl/Tk 3.6 or higher.
[http://merv.cs.nyu.edu:8001/~binli/plinda/]
PL/M: 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 for CP/M. Versions of the language included PL/M-80, PL/M-86 and PL/M-286.
[http://www.cpm.z80.de/]

plm80

The source code for the Intel PL/M-80 compiler. This is written in Fortran 66.
[http://www.cpm.z80.de/source.html]

plm2c

A PL/M-286 to C converter.
[http://www.tuxedo.org/~esr/retro/]
Ploticus: 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 pltab program;

error bars; and

legends and annotations.

[http://www.sgpr.net/]
Plotmtv: 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 X-windows.
[ftp://tanqueray.eecs.berkeley.edu/pub/]
[ftp://ftp.funet.fi/pub/sci/math/tela/needed/]
[ftp://ftp.x.org/contrib/applications/]
[ftp://keel.mit.edu/pub/jai/]
[http://web.mit.edu/jai/www/programs.html]
PlotPlus: A general purpose, interactive, command driven, scientific graphics package. 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 NetCDF; integration with nccalc for NetCDF reading, writing, and calculations; 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 Peters; 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 PostScript format. See also the EPIC package which uses this for plotting.
[http://www.halcyon.com/www2/dwd/]
Plotter: 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 or Motif. It is not 3-D and cannot do pie charts or other non-XY type graphs.
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 specified;

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 structures.

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.
[ftp://ftp.uni-paderborn.de/unix/tools/]
plotutils: The GNU plotting utilities are a library and a collection of programs for plotting 2-D scientific data. The libraries are:

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.

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.
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 Texinfo format.
[http://www.gnu.org/software/plotutils/plotutils.html]

plotter.pm

A Perl module for the C++ libplotter component of plotutils.
[http://w3.man.torun.pl/~makler/prog/Plotter/]

plot_wrap

A Python module that implements the libplot part of the plotutils package. This was created using SWIG.
[http://www.npl.uiuc.edu/~miller/python/]
PLplot: 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:

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 fill patterns;

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.

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.
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.
[http://emma.la.asu.edu/plplot/]
[ftp://dino.ph.utexas.edu/plplot/]

plplot-python

A Python module that implements the functionality of the PLplot graphics package. This also requires NumPy.
[http://www.geog.ubc.ca/~phil/python/plplot.html]
PLTMG: 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).
[http://www.netlib.org/pltmg/index.html]
Plug-and-Play: 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.
[http://www.redhat.com/linux-info/pnp/]
Plugger: See under Netscape.
Plume: 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 Java package. This used to be called SurfIt.
[http://tcltk.anu.edu.au/SurfIt/]
PLUMP: 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 elements;

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 refinement;

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 research purposes. It is documented in a user's guide in PostScript format.
[ftp://ftp.cscs.ch/pub/CSCS/libraries/PLUMP/]
Pluribus: A Web-based search engine that remembers which pages its users like or don't like and uses the information to return filtered results. 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 requires MySQL.
[http://keilor.cs.umass.edu/search/]
PLUS: 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:

transparent communication among the most popular MIMD programming environments;

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 load.

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 PVM, MPI and PARIX. Documentation includes a technical report and a slide presentation.
[http://www.uni-paderborn.de/pc2/projects/mol/plus.htm]
plusFort: 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.
[http://www.polyhedron.co.uk/pf/pflinux.html]
Plush: 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 retesselation;

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.
[http://www.nullsoft.com/plush/]
PlutoPlus: 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).
[http://ipsec-wit.antd.nist.gov/newipsecdoc/pluto.html]
PM: 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 programs, etc. 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.
[ftp://ftp.irisa.fr/local/pm/]
PMan: 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 capabilities. Source code and Linux binary distributions are available, with the former requiring the FLTK widget set for compilation.
[http://r10k.webcity.nl/pman/]
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 solver. A source code distribution is available. It is built on top of MPI and will work on most implementations of that package.
[http://www.idris.fr/data/publications/PMD/PMD.html]
PMD: Parallel Molecular Dynamics is a scalable, parallel program for efficiently simulating the molecular dynamics of biological macromolecules. It uses the Greengard/Rokhlin Fast Multiple Algorithm to allow the simulation of very large systems without sacrificing long-range Coulomb interactions. The features of PMD include:

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. PVM, MPI or TCGMSG.

See Windemuth (1995).
[http://tincan.bioc.columbia.edu/pmd/]
pmm: 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 conference application. 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.
[http://www.cs.columbia.edu/~hgs/pmm/]
PMPIO: A portable implementation of the MPI-IO interface. 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:

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 cb_buffer_size,

error handling, and

full C and Fortran 77 interfaces.

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.
[http://parallel.nas.nasa.gov/MPI-IO/pmpio/pmpio.html]
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) PVM, MPI, 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 and migration.
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 parallelism. 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.
[http://www.ens-lyon.fr/~rnamyst/pm2.html]
Pmw: 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 commands.
A source code version of Pmw is available. It is written in Tk and Python and also requires the Tkinter package. Full documentation is included in the package and is also available onsite.
[http://www.dscpl.com.au/pmw/]

Next: Pn-Pz Up: Linux Software Encyclopedia Previous: On-Oz Contents

Manbreaker Crag 2001-03-08