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 filt