Next: Qa-Qm Up: Linux Software Encyclopedia Previous: Pa-Pm Contents

Pn-Pz

Last checked or modified: Oct. 29, 1998

PNG: Portable Network Graphics is a format for portable graphics, as you might surmise from the name. PNG unofficially stands for PNG's Not GIF, which originates from the decision of Unisys and CompuServe to require royalties from programs using the GIF format since Unisys has a patent on the LZW compression format used therein. The main advantages which PNG has over GIF are:

alpha channels (variable transparency),

gamma correction (cross-platform control of image brightness), and

2-D interlacing (a method of progressive display).

It also compresses better in almost every case, with the difference generally ranging from 10% to 30%. Since PNG is intended to be single-image format only, it doesn't feature multiple-image support. PNG also has the advantage that it has one and only one official pronunciation, i.e. ``ping.''
Standard PNG features include:

support for three main image types, i.e. truecolor, grayscale, and palette (with JPEG supporting the first two and GIF only the third);

compression filters which are a way of transforming the image data (losslessly) so it will compress better; and

file integrity checks, e.g. an 8-byte magic signature at the beginning of every image, a 32-bit cyclic redundancy check, and an Adler-32 checksum applied to the complete stream of uncompressed data.

PNG-related software includes:

libpng, the PNG library;

gd,

gforge,

Ghostview,

GIMP,

Gnuplot,

ImageMagick,

PIL,

pngcrush,

xli,

xpaint and

xv.

Web browsers which support the PNG format include Amaya, Arena, Chimera, Grail, Mosaic, Netscape, and XEmacs.
[http://www.cdrom.com/pub/png/]
[http://www.hensa.ac.uk/png/home/]
[http://www.graphicswiz.com/png/]

libpng

A companion library to the PNG specification written to reduce the amount of time and effort it takes to support said specification. Libpng is designed to handle multiple simultaneous sessions, to be easily modifiable, and to be portable to most machines. It uses zlib for the compression and decompression of PNG files.
The source code for libpng, written in C, is available and should compile on most machines since that is a design goal. It is documented in an ASCII file included with the distribution.
[http://www.cdrom.com/pub/png/pngcode.html]

pngcrush

A batch-mode compression utility for PNG images. This reduces the size of the PNG datastream by trying various compression levels and filter methods.
[http://www.xnot.com/pmt/pngcrush/]
PNG Magick: See under the Netscape entry since this is a Netscape plug-in.
PNM: See Pbmplus.
Pnuts: A scripting language for the Java environment. It was designed to provide a simple interface to manipulate Java objects and to be called easily from Java programs, and is particularly useful for debugging and prototyping. The features of Pnuts include:

full access to all public members and constructors of the Jav API (although it lacks the capability of defining classes);

an expression-based (i.e. interpreted) environment;

integration of primitive and reference data types;

a pseudo list notation implemented as an array of objects;

functions that can take an arbitrary number of parameters and which are identified by the name and number of parameters;

no typing of variables, i.e. no declarations; and

packages that provide naming scopes.

A source code distribution is available which requires JDK 1.1 or better.
[http://www.etale.com/pnuts/]
POC: The Portable Object Compiler is described in the OBJC entry.
pod2ps: A program which takes one or multiple Perl POD files and produces a single PostScript file. It can be run on single or multiple files from the command line or using a script or command file. The output includes PDFMARK operators that can be used by the Adobe Acrobat Distiller program to produce a fully indexed PDF file.
[http://www.oasis.leo.org/perl/scripts/textproc/pod2ps.dsc.html]
Point: A text editor specifically designed to use the mouse as much as possible in editing. Point provides convenient ways to keep a number of windows open on files and to copy text between and within files using the mouse.
The features of Point include:

an unlimited number of windows and files;

easy moving and copying within and among windows;

complete configurability including menus, key bindings, titles, etc.;

extensive options for modifying the look and feel;

the use of Tcl/Tk as a macro language and graphical toolkit;

several searching options including for selection, last string searched for, a regular expression, the last regular expression, a string in a list of files, or a C tag;

file browsers;

circular mouse menus, i.e. gesture commands; and

unlimited undo, redo, and again.

A source code distribution of Point is available. It is written in C with compilation and use also requiring Tcl 7.0 or greater or Tk 3.3 or greater. It is documented in a user's guide available in PostScript format as well as in a man page. A brief FAQ is also included.
[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]
POISS: A package of Fortran 77 routines for the rapid solution of certain types of elliptic equations in rectangular and irregular domains. Specifically, solutions are found for the nonseparable self-adjoint elliptic problem in 2-D polygonal domains with Direchlet boundary conditions. Helmholtz and Poisson problems in polygonal domains and the general variable coefficient problem in a rectangular domain can be treated as special cases of this. The solution method combines the use of the capacitance matrix method (for treating the irregular boundary) and an efficient iterative method (using the Laplacian as a preconditioner) to deal with nonseparability. Each iterative step thus involves solving the Poisson equation in a rectangular domain. This is TOMS algorithm 732 and is documented in Cummins and Vallis (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
POLIS: A framework and package for the hardware-software co-design of embedded systems, especially those which are control-intensive, reactive, real-time systems. Examples of the types of systems for which POLIS is designed included microwave ovens, cameras, telephone switches, cellular phones, engine controllers, anti-lock brake controllers, robots, and plant monitors. The POLIS system is based around a single finite state machine-like (FSM) representation called a co-design finite state machine (CFSM). The CFSM transforms a set of inputs into a set of outputs with only a finite amount of internal state. It differs from FSMs in that the synchronous communication model of the FSM is replaced by a finite, non-zero, unbounded reaction time model in the CFSM. This model can be described as globally asynchronous and locally synchronous, with CSFM specifications a priori unbiased towards either a hardware or software implementation. The chief advantage of the abstract CFSM model is that is covers the behavior of all possible hardware-software implmentations at once.

In POLIS specifications are written in a high-level language such as Esterel that is directly translated into CFSMs. The formal specification and synthesis methodology uses many of the methods available for CSMs (e.g. VIS) which are applied via the inclusion of a translator from CFSMs to FSMs. The methodology also incorporates a set of abstraction and assumption rules specific to CFSMs and POLIS which makes is possible to verify designs larger than was previously possible. A co-simulation process is used which lets the designer test a wide range of choices for hardware/software partitioning and CPU and schedular selection, with the Ptolemy package currently used as a simulation engine. The portions of the CFSMs chosen for hardware implementation are optimized using logic synthesis techniques from the SIS package. The portions to be implemented in software are mapped onto a software structure which includes a procedure for each CFSM together with a simple real-time operating system. The reactive behavior of the CFSM portions is synthesized by first implementing and optimizing the desired behavior in a high-level, processor-independent form similar to a control/data flow graph, which is then translated into portable C code for further optimization on a given compiler. An application-specific OS consisting of a schedular and I/O drivers is generated for each partitioned design. The interfaces between the hardware and software domains are automatically synthesized within POLIS, and come in the form of cooperating circuits and software procedures embedded in the synthesized implementation.

A source code distribution of POLIS is available as are binaries for several platforms including Linux Intel. The source can be compiled on most UNIX flavors using the GCC compiler. The documentation includes a user's manual in PostScript format.
[http://www-cad.eecs.berkeley.edu/Respep/Research/hsc/abstract.html]
POLKA: A general purpose animation system particularly well-suited to building animations of programs, algorithsm, and computations (especially parallel computations). POLKA provides its own high-level abstractions to make the creation of animations easier and faster than with many other systems, with programmers not needing to be graphics experts to develop animations. It includes an interactive front-end called SAMBA which is an animation interpreter that reads ASCII commands or animation directives and performs them.
A source code distribution of POLKA is available. It is written in C++ on top of UNIX and X11 and requires either the Motif or Xaw widget sets. It is documented in a technical report available in PostScript format.
[http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html]
POLMAP: A Starlink Project package for the interactive data analysis of linear spectropolarimetric data. A linear polarization spectrum is a set of Stokes vectors which means that spectropolarimetric data is 4-D (and 6-D if the variance arrays of the Stokes parameters are included) and cannot be manipulated using standard spectral analysis packages. POLMAP is designed for the specific needs of these data sets.
TRIPLOT is a command for the flexible display of polarization spectra. It displays triplots which consist of a top panel showing the position angle of the polarization in degrees, a middle section showing the percentage polarization, and a bottom section showing the intensity spectrum. A polarization spectrum may also be plotted in the QU plane using the QUPLOT command. Other commands include MERGE to merge two stack polarization spectra, ISFIT to fit a Serkowksi law to the data using a nonlinear least squares method (in order to subtract the interstellar polarization vector from the intrinisic polarization spectrum), and FITPA and PACALIB for PA calibration.
A binary distribution of POLMAP is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. It is documented in a user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
PolRadTran: A plane-parallel fully-polarized atmospheric radiative transfer model. This package contains separate versions, one for solar or thermal radiation in a medium of randomly oriented particles and one for thermal radiation in a medium of azimuthally symmetrically-oriented particles. The codes are written in Fortran and documented in ASCII README files.
[http://nit.colorado.edu/~evans/polrad.html]
POLSYS_PLP: A Fortran 90 code for solving N complex coefficient polynomial systems of equations in N unknowns using a probability-one, globally convergent homotopy method. The package consists of two modules:

GLOBAL_PLP, contains the derived data types that define the polynomial system, the system partition, and the start system of the homotopy; and

POLSYS, contains the actual solver and its internal routines as well as the routines responsible for root counting.

This also requires some routines from HOMPACK90.
[http://www.netlib.org/opt/index.html]
PolyglotMan: A filter for UNIX man pages. It takes as input man pages formatted for a variety of UNIX flavors (not [tn]roff source) and produces as output a variety of file formats, e.g. ASCII, TkMan, [tn]roff, Ensemble, SGML, HTML, LaTeX, RTF, etc. This is written in ANSI C and should compile on any UNIX box with a C compiler, including Linux. This used to be called RosettaMan.
[http://www.cs.berkeley.edu/~phelps/tcltk/index.html]
Polynomial Toolbox: The latest version of this (version 2) is a commercial product, and no freely editions are available. A Matlab toolbox for performing many types of computations with and on polynomial matrices. The functionality of the toolbox includes:

defining polynomial matrices;

performing operations on polynomial matrices, e.g. transforming them to canonical forms such as Hermite, Smith, echelon, row, column and diagonally reduced forms;

computing determinants and zeros;

performing operations such as addition and multiplication;

performing spectral factorization and computing null spaces;

modeling linear time-invariant systems and transforming polynomial representations thereof to and from other representations;

solving linear polynomial matrix equations; and

solving various types of control problems such as pole placement, H-2 and H-infinity optimization.

Documentation is available in PDF format.
[http://www.math.utwente.nl/polbox/]
Poly3D: A C program implementing boundary elements to provide solutions to boundary value problems of continuum mechanics. Poly3D calculates the displacements and strains and stresses in an elastic whole- or half-space using planar, polygonal-shaped elements of displacement discontinuity. Polygonal elements may have any number of sides (with a minimum of three), and parameters are calculated at specified points or grids defined by the user. Model fractures and surfaces are treated as surfaces of displacement discontinuity (opening or slip). Slip distributions on faults subject to tectonic loading can be calculated as well as the stress and displacement fields around the faults.
[http://pangea.Stanford.EDU/geomech/Software/Software.htm]
POM: The Princeton Ocean Model is a sigma-coordinate, free surface, primitive equation ocean circulation model which includes a turbulence sub-model. It is written in Fortran 77 and is documented in a large manual in PostScript format.
[http://www.aos.princeton.edu/WWWPUBLIC/htdocs.pom]
POOMA: Parallel Object-Oriented Methods and Applications is an object-oriented framework for developing applications in computational science that require high performance parallel computers. It is implemented as a library of C++ clases designed to represent the common abstractions found in such applications. It is designed to achieve high performance on both single processor and shared-memory multiprocessor machines. This is accomplished by presenting the data parallel programming interface at the highest abstraction layer and encapsulating distribution and communication of data among processors in lower implementation layers. This means that codes developed on serial workstations port to all supported architectures.
The current (12/98) release provides multidimensional arrays using a wide variety of storage schemes and parallel decompositions, multithreading, and out-of-order execution for maximum performance. Planned features include fields, coordinate systems, particles, and parallelism on distributed memory multicompters and networks of workstations using MPI. See Reynders III (1998).
[http://www.acl.lanl.gov/pooma/]
POP (ocean): The Parallel Ocean Program ocean circulation model is a descendant of the Bryan-Cox-Semtner class of finite-difference models, with several improvements that improve both the computational performance and the physical accuracy. These include:

a formulation of the barotropic surface mode based on surface pressure (rather than the streamfunction) which allows any number of islands to be included at no additional computational cost as well as more realistic, unsmoothed bottom topoography to be used with no reduction in time step;

an implicit free-surface boundary condition that allows the air-sea interface to evolve freely and makes sea-surface height a prognostic variable;

latitudinal scaling of horizontal diffusion which prevents the time step from being severely limited at high latitudes while keeping diffusion large enough to maintain numerical stability;

pressure gradient computation via a linear combination of three time levels, allowing the time step to be increased;

use of domain decomposition in latitude and longitude as well as MPI for ease of use and increased efficiency on parallel machines;

use of general orthogonal coordinates in the horizontal, allowing alternatives to bypass the usual singularity at the North Pole; and

a displaced-pole grid that moves the singularity onto a land mass.

This is written in Fortran 90 and requires an appropriate compiler.
[http://www.acl.lanl.gov/climate/models/pop/]
POP: In systems using the Post Office Protocol mail is delivered to a shared server, with client programs periodically connecting to the server to download all pending mail. This is called a store-and-forward service that moves mail on demand from an intermediate server or drop point to single destination machines. The protocol is described in RFCs 1734, 1957, 2095, and 2195. See Johnson (2000).
Software capable of acting either as a POP mail server or client includes:

BlitzMail

fetchmail

fetchpop

getpop

Mutt

nmh

Popper

Ratatosk

UMT

XCmail

XFMail
Popper: An implementation of the Post Office Protocol (POP) which runs on a variety of UNIX computers to manage electronic mail for Mac and MS-DOS computers. The features of Popper include: an idle timeout, a bulletin board, statistics gathering, an xlst (extended list) command, an uidl (unique identifier list) command, Kerberos, shadow passwords, rpop, an authorization file, logging of mail sent via POP to mail debug, MMDF handling (autodetection), APOP authentication, large site support, i.e. a server mode, a database for bulletin tracking, and Kerberos enabled no enabelable by a switch.
A source code version of this is available with makefiles for many flavors of UNIX included. The package is documented in man pages. A shadow password version of this can be found in the Shadow Ina Box tool suite.
[http://sunsite.unc.edu/pub/Linux/system/mail/pop/]
PoPToP: A PPTP server that allows Linux servers to function seamlessly in a PPTP VPN environment. The current (5/99) release supports Windoze 95/98/NT clients and PPTP Linux clients. The eventual full release will support all Windows clients with a full range of encryption and authentication features.
[http://www.moretonbay.com/vpn/pptp.html]
Porch: A source-to-source compiler that translates C programs into those capable of saving and recovering from portable checkpoints. These checkpoints can be transferred in heterogeneous computer networks such as the Internet and may be restarted on binary incompatible machines. This has been successfully tested on several systems including Linux Intel.
[http://theory.lcs.mit.edu/~porch/]
PORT (Bell): The Portable, Outstanding, Reliable and Tested mathematical subroutine library is a large collection of mathematical subroutines written in Fortran. It covers most traditional areas of numerical mathematics except for statistics. In addition to the mathematical routines, there are several non-numeric routines that constitute what is called the Framework of the library. The Framework consists of error handling, memory stack allocation, and machine-constant specific routines that underly the mathematical routines and contain the platform specific features.
The mathematical routines of PORT are divided into several categories including:

approximation routines for performing best uniform approximation with rational splines, interpolation with splines, least squares approximation to discrete functions, and best uniform approximation to continuous functions;

differential equation routines for both stiff and nonstiff ODEs;

linear algebra software including eigenvalue routines, basic linear algebra modules, least squares routines, and linear equation solving programs;

optimization routines for minimizing functions with one or more variables;

partial differential equations in one spatial variable and time;

quadrature programs for performing numerical integrations;

root finding programs for finding zeros of polynomials, single real roots of functions, single roots of complex functions, and roots of a set of nonlinear equations;

special functions including all elementary functions defined in the ANSI 66 Standard Fortran Library, Bessel functions, and the gamma function;

fast Fourier transforms; and

utility functions including random number generators, arithmetic utilities, functions for evaluating expressions in terms of orthogonal polynomials, operations on 1-D arrays, and printing functions.

A source code distribution of the PORT library is available under a limited use non-commercial license. It is written in Fortran. Documentation is available in PostScript format.
[http://www.bell-labs.com/project/PORT/]
PORT (Netlib): A library of Fortran routines for performing various optimization tasks. The full PORT3 library is a commercial product available from Lucent Technologies, although a subset of the routines is publicly available. An important part of the subset is a set of three subroutines which handle machine dependencies for integers, real numbers, and double precision numbers and which are called, respectively, i1mach, r1mach, and d1mach. The subset also includes aoxtrp, d0xtrp, dalloc, dxtrap, e9rint, enter, entsrc, eprint, erroff, i0tk00, i0tk01, i8save, i8tsel, ialloc, istkgt, istkin, istkmd, istkqu, istkrl, istkst, leave, movebc, movebd, movebi, movebl, movebr, movefc, movefd, movefi, movefl, movefr, mtstak, n5err, nerror, nirall, retsrc, s88fmt, setc, setd, seterr, seti, setl, setr, srecap, stinit, and xtrap.
Also available in the public version of PORT are up-to-date versions of NL2SOL as well as extended variants, i.e. n2f, a version of NL2SNO; n2g, a version of NLSSOL; n2p, a variant of NLSOL that allows the residual vector and Jacobian matrix to be passed in piece rather than all at once; n2[fgp]b, versions of NL2SOL that handle simple bounds; ns[fg], versions for separable nonlinear least squares; ns[fg]b versions for separable nonlinear least squares with simple bounds; and dn[s2][fgp][b ], double precision versions of the above. There are also versions of the SMSNO, SUMSL, and HUMSL algorithms for general unconstrained minimization, e.g. mnf, which uses function values only; mng, which uses function and gradient values; mnh, which uses function, gradient, and Hessian values; mn[fgh]b, versions of the above which handle simple bounds; and dmn[fgh][b ], double precision versions of the above.
[http://www.netlib.org/port/]
port numbers: Special or reserved port numbers are assigned to various Internet protocols or services. For example, port 80 is almost always reserved for HTTP, port 0 for TCP and UDP, and port 119 for NNTP. Many of the numbers from 0 to 1023 are reserved in this way, with quite a few more so-called Registered Ports existing in the range 1024 to 65535. See the lists of:

Well Known Port Numbers
[http://www.con.wesleyan.edu/~triemer/network/docservs.html]

Registered Port Numbers
[http://www.con.wesleyan.edu/~triemer/network/regports.html]

[http://www.faqs.org/rfcs/rfc1700.html]
PORTA: The POlyhedron Representation Transformation Algorithm package is a collection of optimization routines for analyzing polytopes and polyhedra given either as the convex hull of a set of points (plus the convex cone of a set of vectors) or as a system of linear equations and inequalities. PORTA guarantees correct numerical results since only integer operations are performed. If an arithmetic overflow occurs using integer arithmetic then the computations are restarted using double precision integer arithmetic.
The programs in the package include:

traf, which performs a transformation from one of the two representations to the other using a Fourier-Mortzkin elimination algorithm which projects a linear system onto subspaces;

vint, which enumerates all of the valid integral points within given bounds;

fctp, which checks the facet inducing property of a set of linear inequalities for a polyhedron given as a convex hull plus a convex cone;

dim, which computes the dimension of a polyhedron given as a convex hull plus a convex cone; and

portsort, which sorts and formats given system to improve the readability of datafiles.

A source code distribution of PORTA is available. It is written in C and is documented via man pages.
[http://www.zib.de/Optimization/Software/Porta/]
PortScanner: A program that scans TCP ports. The features include strobe-scanning support for faster scanning of standardized network services and subnet scanning to iteratively scan for ports on all machines on a subnet simulteneously. A source code distribution is available.
[http://www.ameth.org/~veilleux/portscan.html]
PortSentry: A system for port scan detection and active defense. This part of the Abacus Project suite of security tools is designed to detect and respond to port scans against a target host in real time. The novel features of PortSentry include:

configurability to run on multiple, simultaneous TCP and UDP sockets so one copy can cover dozens of tripwired services;

stealth scan detection, e.g. detection of SYN/half-open, FIN, NULL, X-MAS and oddball packet stealth scans;

reaction to port scan attempts by blocking the host in real time via either dropping the local route back to the attacker or dropping the attacking host IP into a TCP Wrappers hosts.deny file;

an internal state engine to remember previously connected hosts; and

reporting all violations to local or remote syslog daemons including the system name, time of attack, attacking host IP, and hte port through which the attempt was made.

A source code distribution is available.
[http://www.psionic.com/abacus/portsentry/]
POSES++: A software tool for modeling and simulating arbitrary discrete and discontinuous systems. It can also handle suitably discretized continuous systems. POSES++ supports the analysis of existing or planned systems and optimizes them by creating various variants of the system and comparing their performance. It can also be used to generate complex control software by creating a model containing the optimal algorithms for controlling a system, and then creating a binary version of that model for the actual system being modeled. The modeling is based on high level Petri Net definitions. POSES++ can most obviously be applied to the field of logistics, i.e. the safeguarding of investment decisions, the shortening of development cycles, the optimization of such systems, etc.
The POSES++ system consists of several components which each offer flexible and extensible interfaces to other POSES++ tools as well as to external software. The collection of tools comprises a multiserver-multiclient structure whose components communicate using TCP/IP via a command-line interface. The components include:

an Editor used to generate and process models based on a modular design concept with each model capable of being used independently or as a sub-model of some larger model;

a Compiler that checks the syntactic correctness of the source file and then uses it to generate the model needed by the simulation kernel for evaluation of the rules which can also create efficient binary codes for varous hardware and software combinations which represents the executable simulation model;

an Animator and Layout Editor which are used to generate graphical animations of system processes;

a Simulation Kernel which executes the simulation models created by the Compiler and handles necessary communication with the other components; and

an Experiment Tool which supplies the functions needed to execute simulation experiments, e.g. contacting the simulation kernel, selecting the desired model, handling debugging and tracing, etc.

External evaluation tools such as spreadsheets or math packages can also be used by POSES++ via an appropriate interface.
Binary distributions of POSES++ are available for DEC OSF/1, Sun SunOS, HP-UX, and Linux Intel platforms. A user's manual is available in either PostScript or HTML format.
[http://www.tu-chemnitz.de/ftp-home/pub/Local/simulation/poses++/www/]
POSIX: The Portable Operating System Interface is a set of operating system standards. It is an attempt by a consortium of vendors to create a single standard version of UNIX and is intended to define an operating system which behaves like UNIX whether or not it really is UNIX. The POSIX.1 standard defines the System Application Program Interface, i.e. the C procedure calls used in writing programs for UNIX. The POSIX.2 standard defines the Shell and Utilities and is heavily dependent on POSIX.1.
The POSIX.2 standard is the one which will be used to implement user-level commands. The major aspects defined by the POSIX.2 standard are: the Execution Environment Utilities, e.g. cat, kill, etc.; the User Portability Utilities, e.g. more, vi, etc.; the Software Development Utilities; the C Development Utilities; the shell command language; language-independent interfaces for high-level programming languages; and definitions, general requirements, and the UNIX environment, i.e. locales, guidelines for utility command-line syntax, system-wide environment variables, and regular expressions.
The complete POSIX standards (as of 6/97) are (where a designation of the form POSIX.n is short for IEEE 1003.n):

POSIX.0 - guide to POSIX (+)

POSIX.1 - system API for the C language (+)

POSIX.1a - system API extensions (e.g. symlinks, etc.)

POSIX.1b - real-time and I/O extensions (formerly POSIX.4) (-)

POSIX.1c - threads (formerly POSIX.4a) (-)

POSIX.1d - more real-time extensions (formerly POSIX.4b)

POSIX.1e - security extensions and ACLs (formerly POSIX.6)

POSIX.1f - transparent network file access (formerly POSIX.8)

POSIX.1g - protocol independent communications and sockets (formerly POSIX.12)

POSIX.1h - fault tolerance

POSIX.1i - technical corrections to POSIX.1b (-)

POSIX.1j - advanced real-time extensions

POSIX.1k - removable media API

POSIX.1m - checkpointing and restarting

POSIX.1n - fixes to .1, .1b, .1c and .1i

POSIX.1q - tracing

POSIX.2 - shells and common utility programs (+)

POSIX.2a - more tools and utilities (-)

POSIX.2b - more utilities

POSIX.2c - security utilities

POSIX.2d - batch processing utilities (-)

POSIX.2e - removable media utilities

POSIX.5 - Ada binding to POSIX.1 (+)

POSIX.5b - Ada binding to POSIX.1b (-)

POSIX.5c - Ada binding to POSIX.1g

POSIX.9 - Fortran 77 binding to POSIX.1 (+)

POSIX.10 - supercomputing profile (+)

POSIX.13 - realtime profile

POSIX.14 - multi-processing profile

POSIX.18 - POSIX profile

Other POSIX standards which follow a slightly different numbering system are:

IEEE 1387 - system administration

IEEE 1387.1 - overview

IEEE 1387.2 - software administration (+)

IEEE 1387.3 - user/group account administration (+)

IEEE 1387.4 - printer administration

IEEE 2003 - test methodology (formerly POSIX.3)

IEEE 2003.1 - test methods for POSIX.1

IEEE 2003.1b - test methods for POSIX.1b

IEEE 2003.2 - test methods for POSIX.2

Finished and published standards are marked with (+), extensions which have been included in the latest edition of the corresponding main standard are marked with (-), and all others are in the draft stage. Changes in POSIX standard status are announced in comp.std.unix, and the current status can be viewed at the first given URL. See Zlotnick (1991), Lewine (1991), and Gallmeister (1995).
[http://www.pasc.org/standing/sd11.html]
[http://www2.echo.lu/oii/en/api.html]
posix1b: A library containing implementations of some of the functions defined in the POSIX.1b standard that aren't as yet (12/98) present in Linux. These include clock, realtime timer, semaphore, shared memory and message queue functions. The timers are emulated using the BSD interval timer API and the other functions via standard System V IPC.
[http://www.ispras.ru/~knizhnik/]
POSSL: Panther Open Source Software for Linux is an application development environment for building transactional, component-based web applications. Its extensible framework decreases the technical complexity of building distributed applications by providing visual tools, an object repository and application building blocks. The features include:

an import utility to automatically create application objects from database tables;

a screen wizard for generating complex data access forms;

database drivers for automated result set management, data mapping between user interface and databse, and integration with database metadata;

a transaction manager for automatically generated SQL, managed application modality, and optimized SQL including that for multi-table joins and outer joins;

an EJB component builder for drag-and-drop building of components and automatic generation of component interfaces;

team development, debugging, version control and advanced reporting support; and

a class library of pre-built classes, methods and components to jumpstart application development.

The Panther framework provides all the tools nedded for building n-tier client/server applications. The development tools include:

a graphical editing environment for creating screens, reports and service components (specifically EJBs) using widgets such as pushbuttons and data entry fields;

a visual object repository consisting of a central library for creating, storing and accessing objects used for building applications;

a library facility for storing all the objects used in an applications;

a menu bar editor for designing menu bars and toolbars;

a testing environment and built-in debugger; and

a networked library and repository access for cohesive and controlled software development, including repository-stored application objects, interfaces to third-party source control, and access to libraries on remote machines.

The available deployment tools include:

programming language options including the Panther scripting language (JPL), Java or C for adding programming logic to screens, service components and reports;

a styles editor for assigning styles that define an object's color and protection based on the current transaction.

Tools for database access and support include:

drivers for several database engines;

the ability to import database definitions into a repository;

a single-user JDB SQL database for use as a prototyping tool for testing and refining multi-user database applications; and

a runtime transaction manager that performs the processing needed to view and update database information.

Tools for middleware access and support include:

a middleware adapter for connecting the middleware that manages communication between the client and server so the data can be passed from client to middleware, middleware to server, and back again;

the capability of creating service components (i.e. EJBs) to communicate with the IBM WebSphere software; and

runtime support for integration with WebSphere.

[http://www.possl.org/]
Possum: A mathematical tool for the representation and manipulation of finite partially ordered sets (i.e. posets). Possum is designed especially for providing tools for domain theory and the construction of approximations to semantic domains, but can be useful to anyone with an interest in order theory. It can produce Hasse diagrams of the posets that it generates via interaction with the daVinci visualization system. The diagrams are displayed on the screen and can be interactively fine-tuned. They can also be exported as PostScript for printing. Interaction is either through the daVinic GUI or a command-line interpreter which uses the Objective Caml language. The latter allows complicated expressions involving posets to be input concisely.
A source code distribution of Possum is available. Installation requires daVinci 2.0.3 or later and Objective Caml 1.05 or later. The use of the program is documented in several online HTML documents and the algorithms used in a technical report available in PostScript format.
[http://www.comlab.ox.ac.uk/oucl/groups/logfound/possum/index.html]
poster: A program for scaling and tiling a PostScript image for printing on multiple pages. Poster can be used to create a large poster by building it from multiple pages and/or printing it on large media. A source code distribution of this C program is available. It is documented via a man page.
[ftp://ftp.es.ele.tue.nl/pub/other/poster/]
Postfix: An MTA intended as a replacement for sendmail. Postfix attempts to be fast, easy to administer, and secure as well as compatible enough with sendmail to not upset existing users. The features of Postfix include:

performance up to three times as fast as its nearest competitor;

behaving rationally under stressful conditions, e.g. if the system runs out of disk space or memory it backs off rather than make the problem worse;

flexibility via a dozen or so programs that each perform only one specific task robustly and efficiently;

security via multiple layers of defense to protect the system against intruders;

eventual support for multiple transports although the initial release only handles SMTP with some support for UUCP;

support for virtual domains such that adding support for one requires changing only a single lookup table;

UCE control wherein Postfix can restrict what hosts can relay mail through it, and support for restrictions on what mail is allowed to enter; and

extensive use of table lookups rather than the implementation of an address rewriting language.

Several daemons are used by Postfix including:

master, the resident daemon that runs the other daemons on command in a manner similar to inetd with network processes;

smtpd, the SMTP server;

smtp, the SMTP client;

bounce, the message bouncing or deferring daemon;

pickup, the daemon that waits for hints the new mail has been dropped into the maildrop directory;

qmgr, the queue manager daemon that waits for the arrival of incoming mail and arranges for its delivery;

trivial-rewrite, a daemon that handles requests to rewrite and resolve addresses;

local, a daemon that processes delivery requests from the queue manager to deliver mail to local recipients; and

cleanup, a daemon to canonicalize and enqueue inbound mail.

Postfix contains several command-line programs for performing various tasks including:

sendmail, a Postfix to sendmail compatibility interface;

mailq, lists the mail queue;

newaliases, initializes the alias database;

postfix, controls the operation of the mail system;

postalias, maintains alias databases (and is used by newaliases);

postcat, displays the contents of queue files;

postconf, displays the main configuration file parameters;

postdrop, the mail posting agent run by the sendmail command on systems with no world-writable maildrop queue directory;

postkick, makes internal communication channels available for use in, e.g. shell scripts;

postlock, provides mailbox locking;

postlog, provides logging;

postmap, maintains lookup tables; and

postsuper, maintains the Postfix queue.

Source code distributions of Postfix are available as both stable official releases and experimental releases. Documentation is mostly via man pages.
[http://www.postfix.org/]
PostgreSQL: An enhancement of the POSTGRES database management system (DBMS), a next-generation DBMS research prototype. PostgreSQL retains the data model and data types of POSTGRES while replacing the PostQuel query language with an extended subset of SQL. Other enhancements include a program (psql) which supports GNU readline, a new front-end library (libpgtcl) which supports Tcl-base clients, a sample shell (pgtclsh) which provides new Tcl commands to interface Tcl programs with the PostgreSQL backend, a major overhaul of the large object interface, and more.
The features of PostgreSQL that distinguish it from conventional data managers include:

inheritance, i.e. a class can inherit from zero or more other classes and a query can reference either all instances of a class or all instances of a class plus all of its descendants;

time travel, i.e. a feature that allows a user to run historical queries by specifying a time range; and

non-atomic values, i.e. attributes can themselves contain sub-values that can be accessed from the query language, e.g. you can create attributes that are arrays of base types.

The source code for PostgreSQL, written in C, is available and can be compiled using gcc. It has been successfully tested on DEC Alpha, DEC Ultrix, Sun SunOS and Solaris, HP/9000, and Linux Intel platforms. An article about PostgreSQL can be found in the February 1998 issue of the Linux Journal.
[http://www.PostgreSQL.org/]

GtkSQL

A graphical database query tool developed using GTK and PostgreSQL.
[http://www.multimania.com/bbrox/GtkSQL/]

PgAccess

A free database management tool for PostgreSQL. The functionality includes:

opening multiple tables for viewing;

column resizing;

text wrap in cells with the layout saved for every table;

importing from and exporting to external files;

filtering and sorting;

editing in place;

a table generator assistant;

defining, editing and storing user-defined queries;

storing queries as views;

execution of queries with optional input parameters;

query deleting and renaming;

a visual query builder with drag and drop capabilities;

defining, inspecting and deleting sequences and functions in SQL;

designing and displaying simple reports from tables;

saving and loading report descriptions from a database;

a form design module;

defining, modifying and calling user-defined scripts; and

defining and modifying user parameters.

Source and binary distributions are available.
[http://www.flex.ro/pgaccess/]

PoPy

A PostgreSQL driver for Python.
[http://popy.sourceforge.net/]

PyGreSQL

A Python module that interfaces to a PostgreSQL database. It is object-oriented, easy to use, and has several extensions for building GUIs and interfacing with the Web.
[http://www.druid.net/pygresql/]
POSTIE: A mail user agent (MUA) called the ``swiss-army-knife of command-line mailers'' by its author. The features of POSTIE include:

sendmail compatibility for input streaming;

multipart file attachment/extraction;

sending and receiving HTML mail;

support for file-based mailing lists;

inter-host mail relaying;

mailbox masquerading wherein multiple users transparently share a single mail account;

Usenet news posting;

file attachment via wild card file specifications;

NNTP authentication support;

list server processing, i.e. creating public or private mailing lists;

file server processing, i.e. fetching files via email;

uuencoding/decoding of files and attachments;

IMAP4 support including posting;

embedding objects in HTML mail; and

SSLv3 and TLSv1.

A source code distribution of this C++ program is available as are binaries for selected platforms including Linux Intel. This is free for personal use.
[http://www.ozemail.com.au/~adavison/ipostie.html]
Postilion: A mail user agent based on TkRat with the addition of several features including robust support for IMAP in a shared folder environment. This uses IMAP mailboxes to support multiuser environments with system-wide configurations, mailboxes and address books, and shared folders. The source code distribution requires Tcl/Tk 8.0p2 as well as several common image libraries.
[http://www.postilion.org/]
PostScript: A programming language optimized for printing graphics and text. It is a page description language wherein individual pages or images are described in a device independent manner within the source code. It is also a stack-based language, resembling an RPN calculator (e.g. the HP series). A good introduction to the language and its operators is A First Guide to PostScript which is available in both hypertext and PostScript formats. There is also a PostScript Tutorial and Reference in PostScript format.
Useful resources include:

PostScript FAQ
[http://www.smartpages.com/faqs/postscript-faq/top.html]

PostScript Sources FAQ
[http://www.smartpages.com/faqs/postscript/top.html]

PostScript Corner
[http://www.unizh.ch/ps/PScorner.html]

Thinking in PostScript
[http://www.rightbrain.com/pages/books.html]

PostScript Programming Tutorial
[http://devcentral.iftech.com/learning/tutorials/misc/ps/]

Useful PostScript-related software includes:

a2ps, which converts ASCII text into PostScript and sends it to a printer or a file;

Distillery, which ensures that a PostScript document follows the Adobe DSC.

dvips, a program that converts TeX .DVI files into PostScript files;

enscript, which converts text files to PostScript;

epssplit, splits an EPS file into several smaller EPS files;

fontutils, which can convert PostScript fonts to TeX TK format;

Ghostscript, an interpreter;

Ghostview, a previewer;

Groff, which converts troff source into PostScript;

hp2xx, for converting HP-GL graphics into PostScript;

ImageMagick, an image conversion package;

impose++, a set of programs for printing two-up versions of PostScript files;

Lout, a typesetting system;

poster, for creating multiple page posters;

PPST, a benchmarking program for PostScript printers;

PreScript, a PostScript to plain text converter which can also produce rudimentary HTML;

PSPLOT, a library of Fortran-callable routines for creating PostScript graphs;

psrepair, for repairing common defects in PostScript files;

pstoedit, which converts PostScript and PDF files into other vector graphics formats;

pstoepsi, for converting PostScript into Encapsulated PostScript;

pstotext, which converts PostScript files into ASCII text files;

PSTricks, a collection of macros compatible with most TeX macro packages;

psutils, a set of utilities for resizing and various other tasks;

Quikscript, a portable typesetting system written in PostScript;

TinyDict, for PostScript processing that typesets ASCII text into various formats for self-printing books on laser printers; and

Zone, a library of 3-D PostScript operators.

The October 1997 issue of the Linux Journal contains an article about PostScript.
[http://www.ncf.carleton.ca/~cj434/]
POV-Ray: The Persistence Of Vision Raytracer creates 3-D, photo-realistic images using a rendering technique called ray tracing. It reads in a text file containing information describing the objects and lighting in a scene and generates an image of that scene from the view point of a camera also described in the text file. It can also add greater realism to images via a process known as radiosity. It produces very high quality images with realistic reflections, shading, perspective and other effects. The file containing the scene image description cannot be created with the POV-Ray package. This must be done with a separate package called a modeler] that allows you to visually arrange structures.
The features of POV-Ray include:

an easy to use description language;

a large library of example scene files;

standard include files that pre-define many shapes, colors and textures;

high quality output image files in 24-bit color;

creation of landscapes using smoothed height fields;

spotlights for sophisticated lighting;

phong and specular highlighting for more realistic looking surfaces;

many basic shape primitives;

Constructive Solid Geometry for easily combining simple shapes into complex shapes;

many built-in color patterns, surface bump patterns, and textures; and

combinations of textures.

A generic UNIX source code version is available as well as binary versions for Linux, DOS, Mac and Amiga platforms. The documentation is available in both HTML and PostScript formats. Also available are ancillary packages such as PVMPOV for distributing calculations across several platforms.
[http://www.povray.org/]

distpov

A program that allows POV-Ray to distribute rendering tasks across many machines. This connects to each machine, sends an archive containing all the files needed to render a scene, and tells each machine to do a small piece of the image. The features include:

a curses-based progress display on the server machine;

handling more than one job simultaneously;

dynamicallly adding and removing machines;

server state saving so the job can be stopped and started at any time; and

a UDP heartbeat signal for detecting whether machines are down.

A source code distribution is available.
[http://www.cus.umist.ac.uk/~ivarch/linux/distpov.html]

povfront

A front-end for POV-Ray that aims to provide an easy way to launch POV rendering with a graphical interface that manages all of the available options, including those that are ostensibly script-only. This is part of the GIRAM project.
[http://perso.club-internet.fr/clovis1/]

VisualPOV

A graphical interface for POV-Ray created using Tcl/Tk. The components include a toolbar for launching applications, a text editor specializing in the POV-Ray language, a tool for visualizing colors, and a window for changing rendering options.
[http://perso.easynet.fr/~philhay/projet.us.html]
PowerShell: A terminal emulator that supports many terminal windows embedded into a single X11 window, with each given its own notebook tab. The features include:

full GNOME support;

menu options to open a new tab with various programs running;

changing menu options via .pshellrc as well as via the preferences dialog box;

switching terms via CTRL-1, CTRL-2, etc.;

support for transparency and pixmap backgrounds;

full support for color; and

URL handling.

[http://rush.baked.net/~spong/powershell/]
PPBB-Lib: The Portable Parallel Branch-and-Bound Library offers an easy way to parallelize sequential branch and bound algorithms for several architectures. No knowledge of hardware architecture or parallelization mechanisms is needed to use PPBB-Lib. Each parallel running process of the B&B application maintains the point of view of the sequential algorithm, with the library taking over the management of the subproblems creating during execution. Load balancers provided by the library ensure a balanced distribution of the subproblems. It is designed to run on an distributed memory multicomputer architecture using the given message passing functions and a C compiler.
Binary versions of PPBB are available for both sequential and shared memory Linux Intel platforms as well as for several supercomputer platforms. It is documented in a user's manual available in PostScript format. It can be obtained by filling in an online request form.
[http://www.uni-paderborn.de/fachbereich/AG/monien/SOFTWARE/PPBB/]
PPCR: The POSIX Portable Common Runtime package provides integrated user-level support for pre-emptive lightweight threads, garbage collected storage, and dynamic program loading. PPCR can take advantage of kernel thread extensions in the underlying system and should run on any POSIX.1-conforming implementation which also supports BSD select() or System V poll(). It also uses memory protection features available in some systems to support incremental garbage collection.
The source code is available and has been successfully built on Sun SunOS and Solaris, SGI IRIX, Linux Intel, and BSDI platforms. PPCR is documented in an ASCII file in the distribution.
[ftp://ftp.parc.xerox.com/pub/ppcr/]
pPCx: The parallel predictor-corrector package is a parallel version of the PCx package. The source code is written in C with MPI extensions and should be released soon (4/97).
[http://www.cs.cornell.edu/Info/People/mwagner/pPCx/pPCx2.html
ppdd: An advanced encrypted file system for Linux Intel platforms. It is used in a manner similar to the loop device and offers simplicity, speed and full strength 128-bit encryption. A combination of master/working pass phrases offers enhanced security for backup copies. The latest version allows root filesystem encryption to ensure that no plaintext data is left on the disc. This is currently (1/99) in beta test stage and consists of a kernel patch plus some support programs.
[http://pweb.de.uu.net/flexsys.mtk/]
PPI++: The Parallel Portability Interface in C++ is an object-oriented message-passing library. It is designed to serve as a stable interface between the client parallel code and the rapidly evolving distributed computing environments. By taking advantage of encapsulation, inheritance, and polymorphism supported by C++, PPI++ provides a clean and consistent programming interface which helps improve the clarity and expressiveness of client parallel codes and hides implementation details and complexity from the user to ease parallel programming tasks. To benefit fully from the functionalities, portability, and efficiency provided by MPI, the present implementation of PPI++ uses MPI functions to achieve interprocess communication and synchronization. However, the C++ user interface of PPI++ is designed to be very light weight and independent of MPI.
The source code for PPI++, written in C++, is available. The package is documented in several technical reports available in PostScript format and also in Hsieh and Sotelino (1997).
[http://dalmatians.ecn.purdue.edu/~sesde/]
PPM: Abbreviation for the Portable PixelMap graphics format. This is used in the Pbmplus package.
ppmake: A parallel make utility which attempts to run as many parts of a large set of make jobs simultaneously on different computers connected by PVM as is possible. Ppmake requires on changes in makefiles, and can be used as easily as starting PVM on each participating computer and typing ppmake instead of make. The features include interrupt handling, setting timeouts, setting prefix commands, counting jobs, and calculation and display of the degree of parallelism. The ppmake software is available as source code. It's use requires GNU make as well as PVM.
[http://www3.informatik.tu-muenchen.de/~zimmerms/ppmake/]
ppm2fli: A conversion program which converts PPM, PGM, and PBM pictures into FLI animations and vice-versa. This is supposed to be a replacement for fbm2fli.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
PPP: The Point-to-Point Protocol is an Internet standard protocol for the transmission of IP packets over serial (e.g. modem lines. It is designed for simple links transporting packets between two peers with the links providing full-duplex simultaneous bi-directional operation. The three main components of PPP are: (1) a method for encapsulating multi-protocol diagrams; (2) a link control protocol (LCP) for establishing, configuring and testing the data-link connection; and (3) a family of network control protocols (NCP) for establishing and configuring different network layer protocols.

PPP-related software includes:

diald, a dialing daemon for Internet connections;

eznet, a program that automatically sets up and runs PPP;

EzPPP, a Qt front-end to PPP;

gppp, a GTK front-end to PPP;

IsinGlass, a script for making PPP connections more secure;

masqdialer, a daemon for initiating and terminating dialup Internet connections;

pppd, a PPP daemon package;

Visual PPP, a Tcl/Tk front-end to PPP.

[http://cs.uni-bonn.de/ppp/faq.html]
[http://sunsite.unc.edu/pub/Linux/system/network/serial/ppp/]
pppd: A package for implementing PPP. The package consists of two parts:

kernel code that establishes a network interface and passes packets between the serial port, the kernel networking code, and the daemon;

the daemon (pppd) that negotiates with the peer to establish the link and set up the PPP network interface.

The daemon also includes support for authentication. A source code distribution is available which is also included in most standard distributions.
[http://sunsite.unc.edu/pub/Linux/system/network/serial/ppp/]
[ftp://cs.anu.edu.au/pub/software/ppp/]
PPR: A UNIX print spooler designed for operating PostScript printers. PPR is a research project designed to explore the possibilities of the Adobe Document Structuring convention, PPD files, and automatic filtering with the goal of making printing easy for end users.
The features of PPR include:

operation of printers connected to parallel and serial ports, AppleTalk, LAN Manager X clients, LPD servers, and RAW TCP/IP adapters;

capture of messages returned by the printer while a job is printing (if the printer interface supports it);

sending notices to users when jobs are completed or when they fail;

detection of printer faults and automatic attempts to clear them;

interpretation of Document Structuring Convention (DSC) comments to support advanced features such as printer redirection, reverse order printing, collated copies, font downloading, font substitution, and forced duplex mode;

passing print jobs through Ghostscript before sending them to print PostScript files on non-PostScript printers;

automatic detection of non-PostScript output and passage through appropriate filters (e.g. Netpbm, TeX, and Groff);

automatic detection and decompression of compressed files;

printer queue advertising on AppleTalk networks;

accepting jobs for AT&T's LAN Manager for UNIX;]

acceptance of jobs from other computers using the LPD protocol and from the Samba LAN manager;

display of job percentage done in the queue listing; and

printing banner pages.

The code is currently being developed on a Linux system and has also been tested on DEC OSF/1, SGI IRIX, *BSD, and Sun SunOS platforms. The documentation includes installation and user's manuals (available in PostScript and HTML format) and an extensive set of man pages.
[http://ppr-dist.trincoll.edu/printing/pprfaq.html]
PPPui: A GUI for PPP created using Tcl/Tk.
[http://www.teleport.com/~nmeyers/PPPui/]
PPST: A PostScript printer benchmarking program. This tests a printer for the various things it's supposed to do and creates a set of output pages, one for each specific range of tasks. These include:

a bitmap image test that prints three images - two color and one black and white;

a graphics test that tests various graphics operators;

a font test that prints various available fonts;

a memory test that tests the speed of the printer RAM by copying variables from one part of memory to another;

a math test that tests the various mathematical operations; and

a final page containing the statistics for each of the other pages.

[http://www.gaaj.qc.ca/ppst/]
PPTP: The Point to Point Tunneling Protocol is used by Windows NT/95 platforms to create Virtual Private Networks (VPNs). It makes use of the Generic Routing and Encapsulation (GRE) protocol as defined in RFC 1701 and 1702.
[http://bmrc.berkeley.edu/people/chaffee/linux_pptp.html]
Pratt: A tool that searches for patterns conserved in a set of protein sequences. The kinds of patterns to be searched for can be specified as well as the number of sequences that should match a pattern. Other features include:

command line search control wherein values for all parameters can be specified on the command line;

use of upper- and lower-case symbols to differentiate sequences matching wildcard and non-wildcard positions;

extensive online help;

restriction of search areas;

input of multiple sequence alignments of some or all sequences in a set of protein sequences; and

use of branch-and-bound heuristics to make pattern searches more efficient.

A source code distribution of Pratt is available which is written in C and can be compiled on most platforms. A manual is available in HTML format.
[http://www.ii.uib.no/~inge/Pratt.html]
PRAXIS: A Fortran 77 function subroutine that returns the minimum of a function F(X,N) of N variables using the principal axis method. The gradient of the function is not required.
[http://www.netlib.org/opt/index.html]
PRCS: The Project Revision Control System is the front end to a set of tools that provide a way to deal with sets of files and directories as an entity to preserve coherent versions of entire sets. It presents the abstraction of named projects that have multiple versions, each consisting of a set of files arranged into a directory subtree. PRCS attempts to provide a much simpler model than similar packages like RCS or CVS.
The operations allowed by the software include creating a copy of the directory tree for a project version, creating a new project version, searching for differences between project versions, inserting changes that occurred between two project versions (i.e. merging), printing out information about project versions, adding or subtracting the files contained in a new project version, moving files from one subdirectory (i.e. version) to another, etc. PRCS keeps track of all checked-in project versions in a repository and locks them in only while it is actually running.
The source code of PRCS is available as are binaries for FreeBSD, HPUX, IRIX, Linux ELF, Solaris, SunOS and ULTRIX platforms. The present (9/96) documentation is contained within a hypertext document at the site (in HTML format).
[http://www.XCF.Berkeley.EDU/~jmacd/prcs.html]
PRECCX: The PREttier Compiler Compiler eXtended is an infinite-lookahead parser generator for context dependent grammars which generates ANSI C code. Specification scripts are in very extended BNF with inherited and synthetic attributes allowed. Scripts can be compiled in separate modules and later linked together, and meta-production rules are allowed. The technology is essentially LL(oo) with optimizations, and a converter for yacc scripts is available. Lexical analyzers such a lex and flex are suitable pre-filters for PRECCX and are called in the same way that yacc calls them.
A significant feature of PRECCX is the use of parameterized grammar definitions which allow context-dependent grammars. The higher order capability provided by parameterization and the modular arrangement of scripts make parser specifications much more maintainable. The infinite lookahead feature makes the semantics declarative, e.g. a non-terminal can be replaced by its definition without altering the semantics. A newer feature is that attributes can be synthesized on the fly and passed seamlessly into the parser, which extends the declarative programming paradigm from parameterized attribute grammar specifications to fully cover mixed and/or synthetic attributed grammars as well.
A distribution of PRECCX is available for Linux platforms. It is documented in a user's manual available in PostScript format.
[http://www.comlab.ox.ac.uk/archive/redo/precc.html]
PRECISE: The PRecision Estimation and Control In Scientific and Engineering computing package is a set of Matlab tools for setting up and performing computer experiments to explore the impact of finite precision on the quality of convergence of numerical methods. Numerical stability experiments are performed by a straightforward randomization of selected data, after which a sample of perturbed solutions (or spectra) and associated residuals are calculated. Complete statistical backward error analyses can also be performed on numerical methods.
The Matlab routines in PRECISE include:

rnorm, for normwise data perturbations;

rcomp, for componentwise data perturbations;

statinv_comp, for componentwise statistical studies of matrix inversion;

statinv_norm, for normwise statistical studies of matrix inversion;

statlu_comp, for componentwise statistical study of linear systems using LU factorization;

statlu_norm, for normwise statistical study of linear systems using LU factorization;

statqr_comp, for componentwise statistical study of the solution of linear systems using QR factorization;

statqr_norm, for normwise statistical study of the solution of linear systems using QR factorization;

graphlin, for the graphical display of experiment results;

stateig_norm, for normwise statistical study of eigenvalues;

grapheig, for graphical display of eigenvalue studies;

stat_newt, newt, pol, derpol, perpol, for componentwise statistical study of Newton iteration;

graphnewt, for graphical display of Newton experiment results;

pscomp, for componentwise perturbed spectra;

psnorm, for normwise perturbed spectra; and

portrait, couleur, resolv, forme, for obtaining and graphing the spectral portrait of a matrix.

[ftp://ftp.cerfacs.fr/pub/algo/software/Qualcomp/PRECISE/]
premail: A program for the transparent encryption of email whose goal is to add privacy and authentication to existing email clients with a minimum of fiddling while preserving a rich set of functionality including MIME-based multimedia data types. The features of premail include: creation and management of newnym style nyms, some support for S/MIME using RIPEM as the cryptographic engine, integration with Netscape 3.0, support for all cypherpunk remailers, support for Mixmaster remailers, encrypted and signed email including both preparation and decoding, support for the PGP/MIME standard, support for MOSS through TIS/MOSS 7.1, automatic selection of remailer chains, clean handling of ``cc:'' field and other such interactions, and more.
A source code distribution of premail is available. It is written in Perl and requires version 5 or greater. Documentation is available online.
[http://atropos.c2.net/~raph/premail.html]
PREP: A preprocessor for Fortran programs which is an alternative to RATFOR. The features include full macro facilities, a concise shorthand for array and vector statements, and support for all of the standard flow control constructs of Forth. The vector statement notation makes it possible to incorporate do loop unrolling automatically to any depth. The macro processor is a sort of pre-preprocessor for which the order of translation is file inclusion, macro processing, flow control extensions, and vector statements.
A source code distribution of PREP is available. It is written in portable C and can be compiled and used on most generic UNIX platforms. Its use is documented in a user's guide in ASCII format.
[http://sources.isc.org/devel/lang/prep.txt]
Preprocess: A preprocessor for C++ modules. The features include:

transformation of unit-style single source file C++ modules into three output files, i.e. a public header, a private header, and an implementation file;

automatic expansion of class declarations using member function definitions found in the input file;

automatic exporting of functions declared inline, along with all the functions and types they need; and

preservation of all comments.

The drawbacks include not understanding preprocessor constructs other than #include and no support for namespaces.
[http://os.inf.tu-dresden.de/~hohmuth/prj/preprocess/]
preprocessors: Available preprocessing languages and utilities include:

abc2mtex, can be used as a preprocessor for MusicTeX or MusiXTeX;

Basis, includes a Fortran preprocessor;

bibprep, a preprocessor for bibliographical records;

CHPP, a preprocessor originally designed for HTML but much more widely applicable;

cpp, a part of astkit that is a standalone preprocesssor for C;

doxygen, a documentation system with a full C preprocessor;

Dynace, a preprocessor for adding object-oriented features to C;

ELROS, a C preprocessor that produces remote operations from embedded statements;

EPP, an extensible Java preprocessor;

fastpictex, a preprocessor for PicTeX;

GCC, the GNU C compilation system;

gtml, an HTML preprocessor;

HMML, an HTML preprocessor;

HTE, an HTML preprocessor;

HTeX, a preprocessor for embedding LaTeX equations in HTML;

htmlpp, an HTML preprocessor;

igor, a configuration file preprocessor;

iPP, a general preprocessor written in Java;

MPP, a preprocessor for creating MPEG movies;

Ox, a yacc/lex/C preprocessor for bringing attribute grammars to mainstream UNIX;

PREP, a Fortran preprocessor;

Preprocess, a preprocessor for C++ modules;

RATC, a preprocessor for updating the control structures in C;

RATFOR, the classic Fortran preprocessor;

Reactive-C, a language implemented as a C preprocessor;

SEPlib, a package containing preprocessors for Fortran code;

WPP, an HTML preprocessor; and

Y, designed as a replacement for RATFOR.
PreScript: A utility that converts PostScript to plain ASCII or HTML. It first converts a PostScript document to plain text and then inserts rudimentary HTML tags to partly automate the conversion of PostScript documents into HTML. PreScript also determines the line spacing of a document and uses that and indentations to determine paragraph boundaries, removes hyphenations where needed, and detects and translates most ligatures. It is written in PostScript and Python and requires Ghostscript 4.01 or later and Python 1.3 or later.
[http://www.nzdl.org/technology/prescript.html]
presentation software: Package for creating transparencies and/or onscreen presentations for those inevitable and mostly useless meetings and conferences. Listed packages include:

EWIPE, a Tcl/Tk-based package for creating presentations

LaTeX, which has several macro packages for creating presentation slides;

Lout, which has a macro package for creating presentation slides;

Lyx, a front-end for LaTeX which makes using it somewhat easier for neophytes;

MagicPoint, for creating presentations on X11 screens and PostScript slides; and

xdvipresent, a system for creating slide presentations with LaTeX and X11.
Pretzel: A prettyprinter generator that creates modules for prettyprinting from the grammars for various languages including C, Pascal and Java.
[http://www.iti.informatik.th-darmstadt.de/
~gaertner/pretzel/]
PriMa: A printing filter that gives the user the ability to manipulate a document in various ways (e.g. change paper size, print only selected pages or ranges, print duplex, rearrange pages, etc.), to preview a document, and to send it to a file, a printer, mail, fax systems, or other programs. PriMa requires documents in PostScript format, but if they aren't it can use the MagicFilter package to convert a file to PostScript. PriMa is basically an interface built around the psutils package, and as such has all its capabilities.
A source code distribution of PriMa is available. It can be compiled and used on many UNIX flavors including Linux. Compilation requires the XForms library at version 0.86 or newer. It is documented in a README file available in both ASCII and PostScript formats.
[http://sunsite.unc.edu/pub/Linux/system/printing/]
printing utilities: A wide variety of software for enabling and handling the performance of various printing tasks is available for Linux platforms. Useful sites include:

Linux Printing HOWTO
[http://www.picante.com/~gtaylor/pht/]

The available packages include

APSL, a common printing API for GNU/Linux and other UNIX systems

a2ps, a filter for converting nearly any format to PostScript for printing;

CEPS, a printing system designed for medium to large networks;

CUPS, an implementation of the HTTP-based IPP

GNU enscript, a filter for converting text files into PostScript for printing;

FLpr, a script that unifies the usage of several other printing-related programs;

LPRng, an implementation of an LPD-protocol based print spooler;

nenscript, a filter for converting text files into PostScript for printing;

pdq, a straightforward and flexible print; subsystem;

PPR, a print spooler centered on PostScript jobs;

PriMa, a printing filter;

pup, a GUI utility for maintaining printers under Linux; and

rlpr, a network printing utility.
PRISS: The Portable RT[S]P Internet Streaming Server is, as the name indicates, a portable streaming Internet server based on Apple's Darwin Streaming Server. Source code and binary versions are available for Linux platforms.
[http://www.streamingserver.org/priss.html]
Privtool: A PGP-aware replacement for the standard Sun mailtool program with a similar user interface and automagick support for PGP-signing and PGP-encryption. Privtool displays a list of messages along with flags indicating whether they are signed or encrypted and if they have had their signatures verified or have been decrypted. Double-clicking on a message will automatically decrypt and display it (and will also check the signature if necessary). When composing or replying to a message, the resulting message can be digitally signed and/or encrypted. It can also use the Mixmaster anonymous remailer to send the message through one or more remailers.
The source code for Privtool is available at a European site which bypasses U.S. cryptography export regulations. It is known to work on Sun SunOS and Solaris, FreeBSD, and Linux Intel platforms. It is documented on the site as well as in documents in the distribution.
[http://www.unicorn.com/privtool/privtool.html]
PRL: The Programmer's Reusable Library is a family of compatible software libraries intended to promote software reuse. It consists of a layered set of seven libraries with a strong emphasis on computer graphics. These libraries provide a POSIX (POSIX) system interface, programming language primitive data types (PROGRLANG), graphical device drivers (DEVICE), low-level graphics (GRAPHICS), graphical function plotting (PLOT), graphical surface plotting (SURFACE), and graphical cartographic map plotting (MAP).
The seven libraries provide a wide array of capabilities.

The POSIX library is a general purpose Fortran-callable library which provides application programs with access to POSIX functions.

The PROGRLANG library is intended to provide useful operations on Fortran primitive data types as a supplement to the standard set of Fortran intrinsic functions.

The DEVICE library provides a standardized interface to graphics output devices in support of the GRAPHICS library. Currently (4/97) supported devices include DEC LN03, HP LaserJet, PostScript (Level I and II), Tektronix (4014, 4115, 4107, and 4510), X terminal, and Vector Save file format.

The GRAPHICS library provides fundamental 2-D graphics capabilities such as line drawing and graphical text generation. It also supports graphics attributes such as color, line style, line thickness, character shading, and area blanking.

The PLOT library supports the production of 2-D and 3-D function plots. Supported plot types include: 2-D linear, log, log-linear, and polar plots; 2-D bar and pie charts; and 3-D linear and spherical plots.

The SURFACE library supports the production of 2-D and 3-D surface plots. Supported plot types are: 2-D surface line contour and color-shaded contour plots; 3-D surface mesh wireframe (with and without hidden line removal); 3-D surface line contour plots; and 3-D color-shaded contour plots.

The MAP library supports the production of 2-D cartographic projection plots. It currently supports Lambert Equal Area and Cylindrical Equidistant projections and provides two cartographic data bases of the Earth, i.e. low and high resolution databases.

The PRL is available for several platforms and as of 12/15/95 was freely available in binary form for Linux platforms. A user's manual and reference guide in PostScript format are included in the distribution.
[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
[http://isis.iah.com/oa/]
PRM: The Prospero Resource Manager enables users to run sequential or parallel applications on a network of workstations. Sequential jobs are offloaded to lightly loaded processors while parallel jobs use some or all of the processor collection to achieve speedups in execution time. The parallel applications are based on the message passing model and are linked with a communication library which provides routines for sending and receiving tagged messages, broadcasting, and global synchronization. The interfaces available are the CM-5 CMMD library and a PVM interface, both of which allow the development of applications without having to modify any source code for use with PRM. The resource allocation functions of PRM are distributed across three entities: system managers which control access to a collection of processing resources and allocates them to jobs as requested by job managers; job managers which acquire processing nodes from system managers and initiate tasks on these nodes through node managers; and node managers which initiate and monitor tasks on the nodes on which they're running.
The features of PRM include:

utility programs to checking the status of running jobs, query the status of a system manager and the nodes it manages, and to gracefully shut down a PRM system;

the use of an access control list (ACL) to determine whether the host requesting resources is authorized;

library routines for standard I/O tasks and for task creation and resource management;

the checkpoint and migration of tasks to other nodes when the current node makes itself unavailable; and

application debugging.

A source code distribution of PRM is available. It is written in C and should compile and install on many generic UNIX platforms on which PVM is installed. The documentation includes a user's manual and several technical papers, all available in PostScript format.
[http://nii-server.isi.edu/gost-group/products/prm/]
PRMS: The Precipitation-Runoff Modeling System is a modularly-designed, deterministic, distributed-parameter modeling system developed to evaluate the impacts of various combinations of precipitation, climate, and land use on streamflow, sediment yields, and general basin hydrology. Basin response to normal and extreme rainfall and snowmelt can be simulated to evaluate changes in water-balance relationships, flow regimes, flood peaks and volumes, soil-water relationships, sediment yields, and ground-water recharge. Parameter optimization and sensitivity analysis capabilities are provided to fit selected model paramters and evaluate their individual and joint effects on model output.
PRMS divides a watershed into subunits based on basin characteristics such as slope, aspect, elevation, vegetation type, soil type, land use, and precipitation distribution. Two levels of partitioning are available, with the first dividing the basin into homogeneous response units (HRU) based on basin characteristics. The sum of responses for all HRUs, weighted on a unit area basis, produces the daily system response and streamflow for a basin. The second partitioning level is used for storm hydrograph simulation. In this level the watershed in conceptualized as a series of interconnected flow planes and channel segments. Surface runoff is routed over the flow planes and into the channel segments, and channel flow is routed through the watershed channel system. An HRU can be either the equivalent of a flow plane or can be separated into a number of flow planes.
A source code distribution of PRMS for UNIX platforms is available. The primary documentation is contained within Leavesley et al. (1983). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/prms.html]
[http://www.geogr.uni-jena.de/software/prms.html]
PRNGlib: The Parallel Random Number Generator library provides several pseudo-random number generators via a common interface on any shared or distributed memory parallel architecture. Common routines are specified to initialize the generators with appropriate seeds on each processor and to generate uniform, normal, Poisson or exponential distributed random vectors. Lagged Fibonacci, generalized shift register, and multiplicative linear congruential generators are implemented with almost arbitrary specifications for lags, multipliers, moduli, etc. Also included in the package are a set of support routines, test routines, and example programs parallelized using the MPI library. The library is documented via a user's manual in PostScript format.
[ftp://ftp.cscs.ch/pub/CSCS/libraries/PRNGlib/]
procmail: A powerful set of tools which enable the automatic processing of mail either as it is received or after it is already in a message folder. The package consists of three programs: procmail, formail, and lockfile.
The features of the procmail program include:

small size, easy installation and simple to maintain and configure;

event driven invokation and no use of temporary files;

use of standard egrep regular expressions;

low use of system resources;

easy yes-no decisions on where the mail should go;

neural net type weighted scoring of mail messages;

reliably filtering, delivering, and forwarding mail;

a reliable hook for starting any programs or shell scripts upon mail arrival;

good performance under bad system conditions;

absolutely undeliverable mail is bounded back to the sender;

reliable mailbox locking across NFS;

support for four mailfolder standards;

provision of a mail log file chock full of gory details;

display of a wide variety of diagnostic and error message (using the mail log);

no limits on line length, mail length, or the use of any character;

secure system mailbox handling;

provision for controlled execution of programs and scripts from the alias file;

allowing for shifting of system mailboxes into home directories;

clock skew immunity; and

works with sendmail, ZMailer, smail, MMDF, and mailsurr.

The formail program features include

generation of auto-reply headers;

conversion of mail into standard mailbox format (for processing with a standard mail program);

splitting up mailboxes, digests, and saved articles into individual messages;

simple header munging/extraction;

extraction of messages from mailboxes; and

recognition of duplicate messages.

The lockfile program provides NFS-secure lockfiles to shell script programmers and gives normal users to ability to lock their system mailbox regardless of the permissions on the mail-spool directory.
The source code for the procmail package, written in C, is available on can be installed on most generic UNIX platforms (since the code is POSIX, ANSI C and K&R conforming). The documentation is contained within a veritable ocean of man pages.
[http://www.procmail.org/]
[http://www.best.com/~ii/internet/robots/procmail/]

filtmail

An extensible email filtering package developed to circumvent the limitations and arcane syntax of procmail (although it still requires and uses the latter). The packages includes several filters including those for addresses, the domain of the sender, the login of the sender, phrases in the message content, bogus domains, and phrases in the subject line. A vacation filter is also included. A source code distribution of this Perl package is available.
[http://www.best.com/~pjl/software.html]

procmail-lib

A collection of procmail scripts for building an advanced mail handling system. The scripts include:

ackmail.rc, a set of recipes for performing auto-acknowledgement of incoming mail;

commands.help, a file of information sent in response to mail requests for information;

commands.rc, a set of recipes which recognize commands in the Subject header and perform them;

dupcheck.rc, a recipe file which removes duplicate mail;

get-from.rc, a recipe file which extracts the best address from the various originating address fields;

guess-mua.rc, a recipe file which attempts to guess the current MUA;

headers.rc, which defines some variables which can be used for matching against headers; and

unread-mh.rc, a recipe file which attempts to compute how many unread messages there are for an MH user.

[http://www.fr.debian.org/Packages/unstable/mail/procmail-lib.html]
procps: This package consists of a library which parses the textual /proc filesystem and a suite of utilities which uses the library. The utilities are:

ps, which gives a snapshot of the current system processes;

uptime, which tells how long the system's been running;

w, which displays information about the users on the machine and their processes;

free, which displays the total amount of free and used physical and swap memory in the system;

pstree, which shows running processes as a tree;

killall, which sends a signal to all processes running any of the specified commands;

fuser, which displays the PIDs of processes using specified files or filesystems;

top, which displays the top CPU processes;

tload, which prints a graph of the current system load average;

vmstat, which reports information about processes, memory, paging, block I/O, traps, and CPU activity;

sessreg, a program for managing utmp/wtmp entries for xdm sessions;

psupdate, which updates the /etc/psdatabase file to correspond to the current kernel image system map file;

watch, which watches a program as it changes;

skill, which sends the terminate signal to a set of processes;

snice, which alters the scheduling priority of selected processes;

xmem;

xload, which displays a periodically updated histogram of the system load average;

xidle;

XConsole, which displays kernel messages in an X Window;

xcpustate, which displays bars showing the percentage of time the CPU spends in different states;

psdatabase; and

psdevtab.

The procps utilities are available in source code as well as in executable form, with both included in the distribution. Each program is documented in a man page.
[http://sunsite.unc.edu/pub/Linux/system/status/ps/]
PROFIL/BIAS: The Programmer's Runtime Optimized Fast Interval Library is a C++ class library supporting the most commonly needed interval arithmetic and real operations. The supported data types are INT, REAL, INTERVAL, vectors and matrices of these types, and complex numbers. PROFIL is based in BIAS (Basic Interval Arithmetic Subroutines), a package which aims to do for interval arithmetic what BLAS has done for non-interval arithmetic, i.e. provide an interface for basic vector and matrix operations with specific and fast implementations for various architectures. The difference between the two is that all interval operations of PROFIL are independent of the internal representation and implementation of the interval types.
The PROFIL/BIAS library includes various scalar interval, vector, integer vector, matrix, interval matrix, and integer matrix operations. It also contains a large selection of standard functions, e.g. trigonometric and log functions, absolute value, etc., as well as utility functions for finding matrix inverses, transposes, identities as well as some interval vector functions. There are also linear system solvers which compute the enclosures of solution sets. There is a procedure for using Fortran library functions with the library, and multiple precision arithmetic is also possible. An extension package called PROFEXT is available which contains miscellansous functions, test matrices, subroutines for local minimization, general linear singly linked lists, automatic differentiation subroutines, sample programs, and instructions on how to adapt the library to non-supported architectures.
Compilation of PROFIL/BIAS on UNIX systems requires the use of the dmake utility. The source code is configured to compile and installed on several platforms, including Linux Intel. An extensive user's and reference guide is available in Texinfo format.
[http://www.ti3.tu-harburg.de/indexEnglisch.html]
ProFit: A least squares fitting program that fits one protein structure to another, allowing as much flexibility as possible.
[http://www.biochem.ucl.ac.uk/~martin/programs/index.html]
ProFTPD: An FTP daemon for UNIX systems that is designed to be secure and highly configurable. The features of ProFTPD include:

a single main configuration file with directives and directive groups similar to those in Apache;

a per directory .ftpaccess configuration;

configurable multiple virtual FTP servers and anonymous FTP services;

running either as a stand-alone server or from inetd;

no required directory structure, system binaries, or other system files in FTP root directories;

no insecure SITE EXEC command, i.e. no external programs are ever executed;

hidden directories or files;

runs as a configurable non-privileged user in stand-alone mode;

logging and UTMP/WTMP support; and

shadow password suite support.

A source code distribution is available.
[http://www.proftpd.org/]
Progol: An inductive logic programming (ILP) system which combines inverse entailment with general-to-specific search through a refinement graph. Inverse entailment is used with mode declarations to derive the most-specific clause within the mode language which entails a given example. This clause is used to guide a refinement-graph search. The Progol search is efficient and has a provable guarantee of returning a solution having the maximum compression in the search-space. It does this by performing an admissible A*-like search guided by compression over clauses which subsume the most specific clause. It deals with noisy data by using the compression measure to trade-off the description of errors against the hypothesis description length, and allows arbitrary Prolog programs as background knowledge and arbitrarily define clauses as examples.
Progol is available in a source code distribution. It is written in ANSI C and can be compiled and used on most UNIX platforms. It is documented in a user's manual available in PostScript format. See Muggleton (1995).
[http://www.comlab.ox.ac.uk/oucl/groups/machlearn/progol.html]
ProgrammerHTML: A Perl script implementing a small extension to HTML that allows programmers to write more sophisticated Web pages. The main idea is that the programmer defines how a certain tag is rendered as well as the language in which the script, program, or external program is written. A source code distribution is available.
[http://the-labs.com/ProgrammerHTML/]
programming/development environments: Programming environments available for Linux include:

Basis, a development environment for creating Fortran programs;

Chicory, an IDE for Java;

Code Crusader, built using the JX toolkit;

FarGo, a Java-based environment for developing mobile-component based distributed applications;

Free Builder, an IDE for Java;

gIDE, a GTK-based IDE for C;

GRASP, a environment for the graphical representation of algorithms, structures and processes;

Jipe, an IDE for Java;

KDevelop, a development environment for UNIX/X11 platforms;

Moonshine, an application development environment with modular support for many languages;

Paradigm Visual Make, and IDE written using Tcl/Tk;

RHIDE, an IDE for DJGPP;

Source Navigator, an IDE developed by Cygnus for C, Fortran, C++, Java with a limited free version;

TCL Developer Studio, an environment for developing Tcl applications;

WipeOut, an IDE supporting C, C++, Java, Eiffel and Fortran (with a limited freely available version); and

XWPE, a programming environment for UNIX systems with a curses-like interface.

Editors with extensive programmer-friendly features (e.g. syntax highlighting, compilation from within, etc.) include:

Emacs

FTE

JERED

NEdit

Scriptum

Xcoral

XEmacs

XWB
programming language: Hundreds of programming languages have been at least theoretically proposed since the advent of the use of computers, and compilers have been created for many of these. Over a hundred of these compilers are currently available for use on Linux platforms. A compiler is a program which usually translates source code written in a high level language (e.g. C, C++, Fortran) into the instruction set of a specific computer CPU.
Programming languages have been categorized in more than one way. From a functional standpoint, they are often split into imperative and declarative languages. An imperative program consists of sequences of commands that update variables held in storage, i.e. the program has a state that is altered as the program progresses. Imperative languages have been around the longest and include such oldies as Fortran, COBOL and C. A more recent phenomena are non-imperative or declarative languages. These differ from imperative languages in that they are concerned more with expressing what a program does than how it does it, i.e. unlike imperative languages there is no implicit state that can be modified by assignment statements or other language constructs. Declarative languages are usually split into two further categories called functional and logic languages.
Another categorization scheme splits languages into those that are object-oriented (OO) and those that aren't. Sometimes a further distinction is made among the OO languages between those that support some OO features and those that are more or less completely OO. Another distinction is made between serial and parallel languages, with the former running on machines with a single CPU and the latter on those with two or more CPUs. Yet another distinction is made between compiled and interpreted languages, although this is more a matter of how the language is going to be used rather than its inherent features, i.e. most languages can be used with either a compiler or an interpreter and many have both. Embedded languages are usually smaller versions of regular languages used in processors embedded in some sort of machine rather than a full-blow general purpose computer. Scripting languages are usually identified as those used for the rapid development of prototype software, and as such they are usually interpreted rather than compiled.
The programming language categories for which I've bothered to establish separate entries include:

embedded languages

functional languages

imperative languages

logic languages

object-oriented languages

parallel languages

preprocessors

scripting languages

shell languages

Useful books on the topic include: Friedman et al. (1992), Gunter (1992), Mitchell (1996a), and Wolfe (1996). Interesting review sites include:

Review of Existing Languages

Catalog of Free Compilers and Interpreters

Compiler Internet Resources

Programming Language Research

Programming Languages Virtual Library

Computing Languages List

Programmer's Oasis

Implementations of programming languages (interpreters, compilers, translators, preprocessors, or some combination thereof) include: ABC, AL, AMPL, ANICI, aplc, AppGEN, April, ASpecT, ASPy, ATLAST, Basis, bc, BCPL, beast, Befunge, Berkeley Logo, Beta-Prolog, Bigloo, BinProlog, Bla, BOIL, Bongo, b2c, C, C++, Cambridge Modula-3, Cellang, CH, CHSM, Cilk, cim, CLAIRE, Clean, CLiCC, Clif, CLISP, CM, CML, CMUCL, Cool, COX, C*, CuPit, DIESEL, DrScheme, Dylan, Dynace, Eiffel/S, Elegant, Elk, ELROS, EML Kit, eon, ePerl, Erlang, Esterel, e-TeX, EusLisp, Expect, F, f2c, f2cl, Flick, forth2c, FPKPascal, Gawk, gbeta, GCL, gema, Gentle, gforth, Glasgow Haskell Compiler, Glish, GLU, GNAT, GNUDL, Gödel, Golem, Gorby, gps, g77, Guavac, Guile, Harissa, hc, heitml, HMML, Hobbit, HPFFE, HTML, htp, Hugs, ICI, Icon, ILOG TALK, INTERCAL, Jacl, JACOB, Jade, JAS, JAVAR, JDK, JPP, j2c, JUMP, Kaffe, Kali Scheme, Kawa, LaTeX, lcc, Leda, Lout, Lua, Maisie, Marlais, Marx, MCPL, Mentat, Mercat, Mercury, Merle, METAFONT, MetaPost, Mindy, MIT Scheme, ML Kit, MOCKA, Modula-2*, Modula-3, Moscow ML, mpC, MUMPS, MzScheme, Nascent, NESL, Oberon, Objective Caml, Obliq, Octave, OmSim, OPAL, Orca, OScheme, Ox, Oz, Parallaxis, Perl, PFE, Phantom, PHP, Pict, Pizza, PM, Progol, Python, Q, R, Reactive-C, Regina, REXXimc, Risa, RLaB, RNPL, RScheme, Sather, SCC, Scheme 48, Scheme-to-C, SCM, sC++, Self, Shadows, Siod, Sisal, Slang, Slisp, Small Eiffel, Smalltalk/X, SML/NJ, SNOBOL4, SOAR, Spanner, Squeak, SR, Stalin, STBasic, STk, SWI-Prolog, Tcl/Tk, Tela, TeX, ThisForth, Thomas, Toba, uC++, UFO, Uncommon Lisp, VIC, Wild Life, W-Prolog, Xi, XLisp-Stat, Yabasic, YAFL, Yorick, and youtoo.
PROJ: A cartographic projection program designed as a standard UNIX filter utility to be employed with other programs in the generation of maps and charts as well as map digitizing applications. The PROJ package consists of three programs: proj/invproj, which performs forward and inverse transformation of cartographic data to or from cartesian data with a wide range of selectable projection functions; geod/invgeod, which performs geodesic (Great Circle) computations for determining latitude, longitude and back azimuth of a terminus point given an initial point latitude, longitude, azimuth and distance (direct) or the forward and back azimuths and the distance between the initial and terminus point latitudes and longitudes (inverse); and nad2nad, a North American Datum conversion filter to convert between the Datum of 1927 (NAD27) and that of 1983 (and which can also process State Plane Coordinate System (SPCS) and Universal Transverse Mercator (UTM) grid data as well as geographic data for both input and output).
The projections included in the first release were:

cylindrical projections, e.g. Mercator, Transverse Mercator, Universal Transverse Mercator, Oblique Mercator, Central Cylindrical, Transverse Central Cylindrical, Miller, Lambert Cylindrical Equal Area, Gall (Stereographic), Transverse Cylindrical Equal Area, Equidistant Cylindrical, and Cassini;

pseudocylindrical projections, e.g. Sinusoidal, Mollweide, Robinson, Eckert I through VI, Goode Homolosine, Hatano Asymmetrical Equal-Area, Loximuthal, McBryde-Thomas Flat-Polar Parabolic (or Quartic or Sinusoidal), Putnins P, Quartic Authalic, Winkel I, Boggs Eumorphic, Collignon, Denoyer Semi-Elliptical, and Craster Parabolic;

conic projections, e.g. Lambert Conformal Conic, Equidistant Conic, Perspective Conic, Albers Equal Area, Lambert Equal Area, Bipolar Oblique Conic Conformal, Polyconic (American), Rectangular Polyconic, and Bonne;

azimuthal projections, e.g. Stereographic, Universal Polar Stereographic, Orthographic, Airy, Near-Sided Perspective, Lambert Azimuthal Equal Area, Azimuthal Equidistant, Hammer, Wagner VII, Aitoff, and Winkel Tripel; and

miscellaneous projections, e.g. August Epicycloidal, Bacon Globular, Nicolosi Globular, Fournier Globular I, Apian Globular I, Eisenlohr, Ortelius Oval, Van der Grinten I through IV, and Lagrange.

More projections were added in a second release of the package including:

Two Point Equidistant (Doubly Equidistant),

New Zealand Map Grid,

LANDSAT grid,

50 United States Modified Stereographic,

Alaska Modified Stereographic,

Lee Oblated Stereographic,

Miller Oblated Stereographic,

Laborde,

Mercator (Wright),

Lambert Conformal Conic (Conical Orthomorphic), and

Oblique Mercator (Rectified Skew Orthomorphic).

A third release added yet more projections including:

pseudocylindrical projections, e.g. Generalized Sinusoidal, Urmaev Flat-Polar Sinusoidal Series, Eckert V, Wager II through VI, Foucaut Sinusoidal, Hatano, Kavraisky VII, Putnins P through P, Craster, MacBryde-Thomas Flat-Polar Parabolic (and Sine and Quartic), Sine-Tangent Series, Nell-Hammer, Robinson, Denoyer, Fahey, Ginsburg VIII, and the Urmaev V Series; and

miscellaneous projections, e.g. Aitoff, Hammer-Aitoff, Eckert-Greifendorff, Larrivée, and Laskowski.

The package contains the source code, written in ANSI C for portability for all three programs. The documentation is contained within three technical reports available in PostScript format (which contain some very nice graphics for most of the projections). This package can be used as a standalone package as input for some other program or with the MAPGEN front-end package.
[ftp://kai.er.usgs.gov/pub/]
PROLOG: The PROgramming in LOGic language is an example of a logic programming language. It was originally designed for artificial intelligence (AI) applications and is based on the notion of defining objects and inferential relationships among classes of those objects. Its theoretical foundations can be found in propositional calculus. It was developed in the early 1970s by Philippe Roussel of the Artificial Intelligence Group at the University of Marseille in France, with the first interpreter implemented in 1972. PROLOG is extensively used in several application areas including theorem proving and problem solving, mathematical logic, natural language understanding, expert systems and knowledge representation, although its limitations have kept it from being used in such areas as numerical programming, data processing and systems programming.
Prolog implementations include:

Beta-Prolog,

BinProlog,

Calypso,

CIAO,

GNU Prolog,

PM,

SWI-Prolog,

WAMCC,

W-Prolog, and

XSB.

See Clocksin and Mellish (1984), Dodd (1990), Kim (1991), Konigsberger and deBruyn (1990), Pereira and Shieber (1987) and Shoham (1994).
[http://www.comlab.ox.ac.uk/archive/logic-prog.html]
[http://www.logic-programming.org/]
Prometheus: A highly parallel multigrid solver for the set of linear equations that arise from 3-D finite element discretizations of PDEs. Prometheus uses multigrid techniques to precondition Krylov subspace methods to solve for x in nonsingular matrix equations of the form Ax=b. The solver library implements two fully parallelized, unstructured multigrid methods: <UL> <LI>a method that automatically constructs the coarse grids using an algorithm based on maximal independent sets and delaunay tesselation, and the restriction operators using linear finite element shape functions on the coarse grid; <LI>an algebraic multigrid method called smooth aggregation. </UL> It is built on top of PETSc and ParMETIS.
[http://www.cs.berkeley.edu/~madams/prometheus/]
Prometheus Project: An umbrella project for a group of individual projects related to PHP and MySQL to develop active content Web sites.
[http://prometheus.zerodivide.net/]

Apache Compile Kit

A Perl script for automatically compiling PHP, Apache and various other modules, normally a daunting task.
[http://prometheus.zerodivide.net/apache_kit/]

Mysql Clustering Toolkit

A package for clustering a set of MySQL servers for providing high availability and/or distributed data. A master server is a write server whose writes are logged by a script and placed into a log database. Other individual servers read from the log database via a pull method that requires a small table on the local host that stores the IDs of the SQL it ran against the database. Such a methodology can be used as a multi-mastered or multi-write solution.
[http://prometheus.zerodivide.net/mysql_cluster/]

Prometheus Application Framework

A framework for building active content web sites. This is not yet releases as of 1/18/00 although there are many screenshots of the development version available.
[http://prometheus.zerodivide.net/app_framework/]

prometheus-library

An API of objects, functions and defines for designing active content sites with minimal effort. The functionality includes:

AutoLoad, loads only the needed classes and their dependencies;

Sessions, stores cascaded state information;

Database Independence, a framework for a database independence layer;

BenchMarking, an object for benchmarking code segments;

UserAuth, an authentication class that takes pluggable backend drivers;

UserDomain, a virtual domain for users within a website;

WebClient, identifies browser capabilities and features;

Unix Utilities, reads UNIX password files;

FileSize, obtains a file size and formats it using the proper conversions;

PageNavigator, for creating multiple page navigation;

UrlObject, for creating URLs;

MimeObject, for figuring out MIME mappings;

Mail, for reading and sending mail via both IMAP and local sendmail; and

Templates, for parsing simple templates.
Pronto: A modularized GTK MUA written in Perl. The features include:

full MBOX support (import and export);

QMaildir support;

read-only HTML mail;

support for GtkHTML and XmHTML widgets;

a built-in help browser;

a smart address book that autocompletes addresses;

message colorization based on quote symbols and their levels;

spelling and autospelling;

MIME support including inbound and outbound attachments;

working hyperlinks within messages;

use of the Perl DBI interface for database flexibility;

non-blocking mail transfers;

multiple POP3 account support;

filters for mail lists including a new message scoring system;

multiple signatures;

autoset reply addresses based on account used to DL message;

schedulable message transfers;

an outbox for storing unsent outbound messages;

context sensitive menus;

sent items and drafts folders;

multiple message selection; and

multiple folders.

[http://www.muhri.net/pronto/]
PROS: A multi-mission X-ray analysis software system designed to run under the IRAF system. PROS is designed to handled the data screening and masking needed due to features of X-ray data such as scarcity, low signal-to-noise ratio, and large gaps in exposure time. It includes routines for spatial, spectral, timing, and data I/O and conversion as well as plotting applications and general algorithms for performing arithmetic operations on image data. The package consists of functional groups called tasks which are in turn grouped into packages. The major packages are:

xdataio, for converting data to and from FITS format;

xplot, plotting routines for X-ray data;

ximages, additions to the IRAF images package;

xspatial, for X-ray spatial analysis;

xspectral, for X-ray spectral analysis; and

xtiming, for X-ray timing analysis.

The tasks contained in the PROS analysis packages include:

display and xdisplay, for producing TV displays of data;

imcontour and skygrid, for calculating and graphing iso-intensity areas of images and displaying them on a sky grid;

coordinates, for working with the World Coordinate System (WCS);

sgraph, for graphing all non-image output files;

detect, for performing maximum likelihood source detection on data with Poisson statistics;

imcalc, immodel and imsmooth, for generating complex point response function model images that can be convolved with observations;

imcnts, for extracting background subtracted counts from complex regions;

timcor, for performing time corrections;

ltcurv, fft, period, fold, qpphase, and phase, for examining periodic data;

qpspec, for extract a background corrected spectrum;

xflux, for calculating fluxes for any object; and

a flexible spectral model specification langauge allowing multi-component model fitting.

A source code distribution of PROS is available as are binaries for selected platforms including Linux Intel. The package is written mostly in C. A user's guide is available in the usual formats.
[http://hea-www.harvard.edu/PROS/pros.html]
Protege: A interactive system for enabling domain experts to build knowledge-based systems by creating and modifying reusable ontologies and problem solving methods. Protege generates domain-specific knowledge acquisition tools and applications from the developed ontologies. It is built as a system of three layers, with each communicating with the layers beneath via well-defined APIs. These layers are:

a widget layer that is a user-interface component allowing a small part of the knowledge base to be viewed and edited;

a control layer that handles standard actions (e.g. menu items) and the connections between widgets and the underlying knowledge base; and

a wrapper around the knowledge base server that is a set of model interfaces specifying what must be implemented.

[http://smi-web.stanford.edu/projects/protege/]
Proteus: An exectutable, high-level, architecture-independent parallel programming notation in which sophisticated parallel algorithms free of complex low-level architecture-specific details can be developed and evaluated. This is a rapid prototyping system which permits the exploration of a large and complex space of alternatives. Proteus represents a refinement based development methodology where the refinement of a program consists of modifying it to reflect restrictions in the use of concurrency constructs, with the restriction expressing the adaptation of a high-level design to constructs efficiently supported on a specific architecture. Programs which are suitably refined in their use of the Proteus notation can be automatically translated to efficient parallel programs in low-level architecture-specific notations, and can then be run directly on the targeted architecture.
The Proteus environment consists of several components:

a program repository organizes different versions of Proteus programs and the low-level generated codes using either CVS or RCS;

a program modification system creates new versions of programs via either manual editing to change the functionality or restriction of a program, or by the automatic generation of a low-level program from a restricted Proteus program;

a program execution system consists of a Proteus interpreter including run-time monitoring and analysis functions as well as an interface to external modules in the form of existing applications or those generated by the translation of Proteus programs; and

a module interconnection facility (MIF) is a socket-based facility managed by the interpreter to permit Proteus programs to communicate with concurrently executing external applications.

Proteus currently (5/97) only works with a CVL library implementation for MasPar computers, but an implementation which will run on top of PVM is being developed.
A sequential Proteus interpreter is currently available in source code format. It should compile and run on many UNIX platforms. The documentation includes a language manual available in PostScript format.
[http://www.cs.unc.edu/Research/proteus/]
ProTeX: A style-independent literate programming system built on top of LaTeX. ProTeX is extensible, language independent, and produces multiple output files.
[http://www.cis.ohio-state.edu/~gurari/systems.html]
protocols: Various computer and network protocols including:

ACAP, the Application Configuration Access Protocol is designed to support remote storage and access of program option, configuration and preference information (2244);

AgentX, a protocol for communication between master agents and subagents within a standardized framework for extensible SNMP agents (2257);

ANEP, the Active Network Encapsulation Protocol;

AODV, the Ad Hoc On-Demand Vector routing protocol is for mobile nodes in an ad hoc network;

AppleTalk

ARP, the Address Resolution Protocol is for converting IP addresses into Ethernet addresses;

ATM, Asynchronous Transfer Mode

BGP, the Border Gateway Protocol is an inter-Autonomous System routing protocol whose primary function is to exchange network reachability information with other BGP systems (1771);

CAMAC, a standard electronic interface system protocol generally used for data acquisition;

CAN, a protocol for a serial bus system with multi-master capabilities;

CBRP, the Client Based Routing Protocol is one designed for use in mobile ad hoc networks;

CMIP, the Common Management Information Protocol

DeviceNet, a networking standard for industrial automation applications;

DHCP, the Dynamic Host Control Protocol provides a framework for passing configuration information to hosts on a TCP/IP network (2131);

DICT, the Dictionary Server Protocol is a TCP transaction-based query/response protocol allowing a client to access dictionary definitions from a set of natural language dictionary databases (2229);

DRP, the Distribution and Replication Protocol is for improving the optimizing the performance of the Web;

DSDV, the Destination Sequenced Distance Vector is a multi-hop ad hoc network routing protocol

DSR, the Dynamic Source Routing is a multi-hop ad hoc network routing protocol

DVMRP, the Distance Vector Multicast Routing Protocol

EGP, the External Gateway Protocol enables networks to exchange information on how to reach other networks;

Ethernet

FDDI, the Fiber Distributed Data Interface

fibre channel, a set of protocols for a 1 gigabit per second data transfer interface technology;

FireWire, a type of high speed serial bus protocol for devices requiring significant bandwidth;

Frame Relay

FTP, the File Transfer Protocol

Gopher

GSMP, the General Switch Management Protocol is a general purpose protocol to control an ATM switch (2297);

HCP, the Human Communications Protocol is for handling any form of communications a human might want to use over a computer network;

HDLC, the High-Level Data Link Control protocol concerns transmitting data at a set flow rate across a network;

HTCPCP, the Hyper Text Coffee Pot Control Protocol is for controlling, monitoring and diagnosing coffee pots (2324);

HTTP, the HyperText Transport Protocol

ICMP, the Internet Control Message Protocol

ICP, the Internet Cache Protocol

IGMP, the Internet Group Management Protocol is used by IP hosts to report their multicast group memberships to routers (2236);

IGRP, the Interior Gateway Routing Protocol for routing within an autonomous system;

IKE, the Internet Key Exchange protocol is for negotiating and providing authenticated keying material for security associations in a protected manner;

IMAP, the Internet Message Access Protocol specifies a method for accessing email that is kept on a mail server;

IOTP, the Internet Open Trading Protocol

IP, the Internet Protocol is the network protocol for the Internet protocol suite;

IPP, the Internet Printing Protocol;

IPSec, Internet Procol Security is the security standard for Internet communications;

IPv6, the next generation IP protocol;

IRDP, the ICMP Router Discovery Protocol

ISAKMP, the Internet Security Association and Key Management Protocol;

ISDN, the Integrated Services Digital Network;

ISL, the InterSwitch Link protocol is for connecting VLAN-capable Ethernet switches;

Kerberos, a network identification protocol

LDAP, the Lightweight Directory Access Protocol is designed to provide access to the X.500 Directory and targeted a simple management applications and browser applications that provide simple read or write interactive access to X.500 (2251);

LDP, the Label Distribution Protocol establishes how Label Switched Routers established Label Switched Paths through a network by mapping network layer routing information directly to data-link layer switched paths;

L2TP, the Layer 2 Tunneling Protocol is a method for encapsulating PPP through various media;

MathML, Mathematical Markup Language provides a method for including math expressions on Web pages;

MGCP, the Media Gateway Control Protocol is for controlling telephony gateways via call agents;

MIME, the Multipurpose Internet Mail Extensions

MMS, the Manufacturing Message Specification is an OSI application layer protocol for the remote control and monitoring of industrial devices;

Mobile IP, a protocol for mobile computer users who wish to connect to the Internet and maintain that connection while moving from place to place;

MOSPF, the Multicast Open Shortest Path First protocol;

MSIX, the Metered Service Information Exchange is a protocol designed to enable ISPs to effectively meter usage;

NDMP, the Network Data Management Protocol

NHRP, the NBMA Next Hop Resolution Protocol is used by a host or router connected to a NBMA subnetwork to determine the internetworking layer address and NBMA subnetwork addresses of the ``NBMA next hop'' towards a destination station (2332);

NFS, the Network File System;

NLSP, the Network Layer Security Protocol;

NNTP, the Network News Transport Protocol

NPMP, the Network Peripheral Management Protocol

NTP, the Network Time Protocol

OKBC, the Open Knowledge Base Connectivity protocol is for accessing knowledge bases stored in knowledge representation systems;

OSI, the Open Systems Interconnection protocol is a seven layer model for network communications;

OSPF, the Open Shortest Path First TCP/IP routing protocol distributes, based on link-state or SPF technology, information between routers belonging to a single Autonomous System (2328);

OTP, the One-Time Password authentication system provides authentication for system access and other applications requiring authentication that is secure against passive attacks based on replaying captured reusable passwords (2243);

PGM, 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;

PGML, a 2-D scalable graphics language;

PIM, the Protocl Independent Multicast, for establishing multicast connections across wide-area internets where groups are sparsely represented and bandwidth not plentiful;

POP, the Post Office Protocol is a store-and-forward mail deliver protocol;

PPP , the Point-to-Point Protocol

RADIUS, the Remote Authentication Dial In User Service protocol provides an open and scalable client/server security system for dial-up access;

RIP, the Routing Information Protocol is one for exchanging routing information among gateways and other hosts;

RPC, the Remote Procedure Call

RSVP, the ReSerVation Protocol is part of a larger effort to enhance the Internet architecture with support for quality of service flows;

RTP, the Real-time Transport Protocol provides end-to-end network transport functions for applications transmitting real-time data;

RTSP, the Real Time Streaming Protocol is an application-level protocol for controlling the delivery of data with real-time properties (2326);

SCSP, the Server Cache Synchronization Protocol attempts to solve the generalized cache synchronization/cache replication problem for distributed protocol entities (2334);

SDP, the Session Description Protocol is intended for describing multimedia sessions for the purposes of session announcement, invitation, and other forms of session initiation (2327);

S-HTTP, the Secure HTTP provides a secure message-oriented communications protocol;

SIP, the Session Information Protocol is a signaling protocol for Internet conferencing and telephony;

SKIP, Simple Key management for Internet Protocols secures the network at the IP package level;

SLIP, the Serial Line Internet Protocol

SMTP

SNQP, the Simple Nomenclator Query Protocol is for querying servers that search collections of data repositories (2259);

SOCKS, a networking proxy protocol that enables hosts on one side of a SOCKS server to gain full access to those on the other side without requiring direct IP reachability by authenticating and authorizing requests, establishing a proxy connection, and relaying the data;

sRGB, a standard default color space for the Internet;

SSL, the Secure Sockets Layer is a security protocol implemented on top of TCP/IP;

SVG, Scalable Vector Graphics is a standard for raster graphics on the Web;

TCP, the Transport Control Protocol is the major transport protocol in the Internet protocol suite;

Telnet

TFTP, the Trivial File Transfer Protocol

TLS, Transport Layer Security is a protocol for providing communications privacy over the Internet;

TNPP, the Telocator Network Paging Protocol defines a mechanism for moving information between paging terminals;

TORA, the Temporally-Ordered Routing Algorithm is a network routing protocol for use with mobile wireless networks;

UDP, the User Datagram Protocol

USB, the Universal Serial Bus is a low speed serial bus protocol both hot-pluggable and plug-and-play;

UCM, Use Case Maps is a notation used to describe the behavior of complex and dynamic systems;

UUCP

VIA, the Virtual Interface Architecture defines a standard architecture for communication within clusters of machines;

VML, the Vector Markup Language defines a format for encoding vector information and markup for displaying that information;

VNET, the Virtual NETwork protocol is a virtual protocol that manages multiple physical network protocols

VRRP, the Virtual Router Redundancy Protocol specifies an election protocol for dynamically assigning responsibility for a virtual router to one of the VRRP routers on a LAN (2338);

VSAP, the Virtual Socket Association Protocol

WAIS, the Wide Area Information Server

WAP, the Wireless Application Protocol is a global wireless protocol specification;

WIDL, the Web Interface Definition Language defines APIs to Web data and sources;

WML, the Wireless Markup Language is HTML designed for use with cellular devices with lower bandwidths;

XMODEM, a protocol for transferring files over asynchronous lines;

XTP, the Xpress Transport Protocol is a transport layer protocol for providing a wide range of communication services via orthogonal transport mechanisms;

YMODEM, a protocol for transferring files over asynchronous lines;

ZMODEM, a protocol for transferring files over asynchronous lines;

ZRP, the Zone Routing Protocol is a hybrid protocol suitable for a wide range of mobile ad-hoc networks.
Protolog: A package containing three daemons for logging the TCP, UDP and ICMP packets arriving at a machine. It also logs IP options and can evade IP sniffer attacks. The programs in the package are:

KillLoggers, a script for killing all the loggers;

LaunchLoggers, a script for starting all the loggers;

ipretlog, interprets raw Protolog output files and outputs a readable report;

plogicmp, the ICMP packet logger;

plogtcp, the TCP packet logger; and

plogudp, the UDP packer logger.

A source code distribution is available. The programs are documented in man pages.
[http://www.grigna.com/diego/linux/]
Protomatter: An Open Source Java application server for building database-driven Web sites. The documentation is currently (7/99) in javadoc format.
[http://www.protomatter.com/]
prototype: A collection of globally-installed shared Makefiles for assisting in project development. Prototype Makefiles also contains Makefile templates that can be copied into project directories using a simple script. The shared Makefiles contain the rules for building a project, clean it and making dependencies, and all the other tedious tasks involved in such things. The Makefile templates contain the data that is specific to each project. Maintenance and extension are easier since this separation avoids duplication of code in Makefiles.
[http://www.xs4all.nl/~carlo17/prototype/]
PROTUX: The free PROfessional audio Tools for LinUX is a project to create a definitive solution for audio professionals who need a suite of powerful and practical software for daily work. It is being patterned on the expensive ProTools commercial software suite, although it will not require special hardware but rather work through the /dev/dsp(n) interfaces via OSS-based drivers.
[http://protux.sourceforge.net/]
pscover: A pair of Perl scripts for combining and extracting a PostScript cover page and an arbitrary PostScript document. These utilities use the Adobe Document Structuring Conventions to create a composite document understandable to printers and previewers.
[http://www.cs.brown.edu/software/catalog.html]
PSD: A set of Matlab scripts for obtaining Power Spectral Density estimates from time series using the maximum entropy and Welch overlapped segment methods. The programs include:

MESA, calculates a maximum entropy spectrum;

WILHIL, calculates the Wilson-Hilferty approximation to the chi-squared distribution;

WOSA, computes a spectral estimate for a time series using the Welch overlapped segment averaging method; and

WOSAPICK, sets up the segments and offsets for WOSA.

[ftp://ftp.gi.alaska.edu/pub/eric/psd/]
PseudoPack: A Fortran software library for numerical differentiation by pseudospectral methods. The features include:

derivatives of up to order four for the Fourier, Chebyshev and Legendre collocation methods based on the Gauss-Lobatto, Gauss-Radau and Gauss quadrature nodes;

a choice of methods for computing the derivative/smoothing of a function including matrix-matrix multiply, even-odd decomposition and FFT;

native fast assembly library calls such as General Matrix-Matrix Multiply (GEMM) from BLAS, FFT and fast cosine/sine transform where available;

special fast algorithms (e.g. fast quarter-wave transform and even-odd decomposition algorithm) for cases when the function has even or odd symmetry;

use of Kosloff-Tal-Ezer mapping to reduce the roundoff error for the Chebyshev and Legendre differentiation;

extensive built-in and user-definable mapping functions for finite, semi-infinite and infinite domains;

built-in filtering (i.e. smoothing) of functions and their derivatives;

application of differentiation and smoothing to either the first or second dimension of a 2-D array;

conservative and non-conservative forms of derivative operators (i.e. gradient, divergence, curl and Laplacian operators) in 2D/3D general curvilinear coordinates; and

a unified subroutine call interface.

The source code is written in Fortran 90 and uses the C preprocessor to compile the code into versions for Cray, IBM R6000, SGI and Sun platforms. The generic port requires BLAS and VFFTPACK, both avaiable from Netlib. The source code is freely available to non-commercial users.
[http://www.cfm.brown.edu/people/wsdon/home.html]
PSGML: An Emacs major mode for editing SGML documents.
[http://www.lysator.liu.se/projects/about_psgml.html]
PSIDE: The Parallel Software for Implicit Differential Equations is a Fortran 77 code for solving implicit differential equations on shared memory parallel computers. PSIDE uses the four-stage Radau IIA method. The nonlinear systems are solved by a modified Newton process in which every Newton iterate is itself computed by means of the parallel iterative linear system solver for Runge-Kutta (PILSRK). This is done so the four stage values can be simultaneously computed on four processors. A source code distribution is available which is documented in user's and reference manuals.
[http://www.cwi.nl/cwi/projects/PSIDE/]
PSI88: A molecular orbital plotting package written in Fortran 77. The components of the model are:

PSI1, generates 3-D volume data from molecular orbital coefficients;

PSICON, extracts contours from the 3-D data; and

PSI2, produces plots from PSICON output.

A source code distribution is available which requires a CALCOMP-compatible graphics library for producing plots.
[http://zarbi.chem.yale.edu/programs/psi88.html]
PSIM: An emulator for the instruction set architecture of the PowerPC microprocessor family. A source code version of this C program is available as is an extensive user's manual.
[ftp://cambridge.cygnus.com/pub/psim/index.html]
psmisc: A collection of /proc-based utilities consisting of:

fuser, which identifies processes using files;

killall, which kills processes by name;

pidof, which lists PIDs of processes specified by name; and

pstree, which shows the currently running processes as a tree.

A source code distribution of these utilities is available.
[ftp://lrcftp.epfl.ch/pub/linux/local/psmisc/]
psntools: A set of utilities specifically designed to easily administer large numbers of user accounts at medium-sized sites (i.e. between 200 and 4000 users). These programs are tailored for education institutions where classes change yearly but are flexible enough for use in different environments. The features iclude the mass addition, removal and disabling of accounts as well as the mass setting of specified or randomly generated passwords. A source code distribution is available.
[http://www.psn.ie/psntools/]
P-SPARSLIB: A set of tools for solving large sparse linear systems on distributed memory computers. Solutions are obtained by first partitioning a linear system, then splitting it according to the partitioning, constructing a distributed data structure, and finally invoking a preconditioned Krylov solver for its solution. It consists of four major parts: accelerators, preprocessing tools, preconditioning routines, and message-passing tools. The accelerators and preconditioners are the functional layer, with the former based on Krylov subspace methods and the latter needed because the former tends to work poorly without preconditioning. The functional modules are designed to be as independent as possible from data structures and the specifics of the message passing libraries used.
The non-functional module contains the message passing layer of the library, which provides an interface between the communication functions used in the library and those in standard communication libraries as well as native libraries of some parallel computers. The routines are designed to exploit redundancy of communications and asynchronous message passing capabilities to reduce latency and allow an overlap between computations and communications. This layer may be phased out in future releases if one of the standard message passing libraries improves sufficiently to supply the desired performance characteristics on the appropriate architectures.
Source code distributions of P-SPARSLIB are available. Versions are available for CM5-CMMD, CRAY-T3D, MPI and PVM platforms. A technical report/user's guide is available in PostScript format.
[http://www.cs.umn.edu/Research/arpa/p_sparslib/psp-abs.html]
PSPLOT: A library of Fortran-callable subroutines for generating two-dimensional technical drawings or graphics in PostScript format. It supports black and white and color graphics, and contains 75 subroutines for performing all the basic operations that are needed for creating technical graphs. PSPLOT is written in Fortran 77, supports the standard 35 PostScript fonts, and is platform independent.
[http://www.nova.edu/ocean/psplot.html]
PSPP: A GNU software package which is an upwardly compatible replacement for SPSS, a powerful tool for the statistical analysis of data used at universities and companies worldwide. The features of Fiasco include:

support for most transformation language features;

support for most statistical procedures;

high quality output formatting including support for ASCII, IBM-PC box drawing and similar formats, and PostScript; and

easily ported ANSI C source code.

The current (9/97) is, in the words of the author, ``woefully incomplete,'' but it still might be useful for basic tasks. This was originally called Fiasco.
[http://www.gnu.ai.mit.edu/software/pspp/]
psrepair: A program that repairs common defects in PostScript files to make them suitable for printing in UNIX environments. The corrected defects are:

translating the CRs found on Mac systems and CR-LFs found on MS-DOS systems to the UNIX line convention, i.e. LF;

removing any non-space control characters such as EOF; and

allowing paper size mismatches for FrameMaker to enable the printing of US letter size documents on A4 printers and vice-versa.

A source code distribution is available.
[http://www.cs.columbia.edu/~hgs/psrepair/]
PStill: A PostScript to PDF converter. It is a level 1 clone interpreter so Level 2 jobs won't run on it (although quite a bit of Level 2 is emulated). It conforms mostly to the PDF 1.1 specification. A binary distribution is freely available for Linux platforms.
[http://www.noir.net/frank/pstill.html]
pstoedit: A program which converts PostScript and PDF files to other vector graphic formats so they can be edited graphically. Pstoedit consists of a PostScript frontend which needs to call an interpreter like Ghostscript and the individual backends which are plugged into a framework. The framework can be used independently from the frontend and provides a uniform interface to all of the different backends. The formats supported by the backends are: debug, XFig, CGM, PDF, Gnuplot, DXF, LWO, Framemaker MIF, RIB, RPL, JAVA, PS, MET, WMF, Tgif, Idraw, and dump.
The pstoedit package is written in C++. It can be compiled using g++. It is documented in a man page as well as in a user's guide in HTML format.
[ftp://ftp.digex.net/pub/X/contrib/applications/pstoedit/]
pstoepsi: A set of scripts for converting arbitrary PostScript to Encapsulated PostScript with an optional preview image. These can generate EPS, EPSI and EPSF formats. The use of pstoepsi requires both the Pbmplus tools and the Ghostscript converter.
[ftp://ftp.cs.purdue.edu/pub/dgc/]
pstotext: A program that works with Ghostscript (version 3.33 or later) to extract plain text from PostScript and PDF files (although the latter requires Ghostscript 3.51 or later). This is written in C and should compile on almost any UNIX platform with a C compiler. The documentation is contained within a man page.
[http://www.research.digital.com/SRC/virtualpaper/pstotext.html]
PSTricks: A collection of PostScript-based TeX macros that allow the inclusion of color, graphics, rotation, trees and overlays in TeX documents.
[http://zandtwerk.kellogg.nwu.edu/tex.html]
[http://www.tug.org/applications/PSTricks/]
PSTSWM: The Parallel Spectral Transform Shallow Water Model is a message passing benchmark code and parallel algorithm testbed which solves the nonlinear shallow water equations (SWE) on a rotating sphere using the spectral transform method. PSTSWM was developed to evaluate parallel algorithms for the spectral transform method as it is used in global atmospheric circulation models. Multiple parallel algorithms are embedded in the code and can be selected at run-time as can the problem size, number of processors, and data decomposition. Six different problem test cases are supported, each with associated reference solutions and solution and error analysis options.
The PSTSWM source code is available. It is written in Fortran 77 with VMS extensions and a small number of C preprocessor directives. Message passing can be implemented with the MPI, PICL, or PVM libraries with the choice being made at compile time. The package is documented in a user's guide and some technical reports, all available in PostScript format.
[http://www.epm.ornl.gov/chammp/pstswm/]
psutils: A set of utilities to process PostScript source code. The utilities include:

psbook, which rearranges pages into book signatures;

psselect, which selects pages and page ranges for printing;

pstops, which performs general page rearrangement and selection;

psnup, which puts multiple pages per physical sheet of paper;

psresize, which alters the size of the document on the paper; and

epsffit, which fits and EPSF file to a given bounding box.

These programs are all written in C and can be compiled and installed on generic UNIX platforms. The programs are documented in individual man pages.
[http://www.dcs.ed.ac.uk/home/ajcd/psutils/]
[http://sunsite.unc.edu/pub/Linux/apps/wp/]
pt: The Pluto Tools perform various operations on text files specified on the command line or standard input. These operations include:

converting any character to upper or lower case;

converting first letters of any word, period, or paragraph to upper case;

switching upper case to lower case and vice-versa;

converting among UNIX, DOS, or MAC text file formats;

removing enters that are not at the end of a paragraph;

converting tabs to spaces and vice versa;

indentation;

simple encryption;

stripping the binary parts of files and 8th bits; and

deleting spaces and tabs at the end of each line.

[http://sunsite.unc.edu/pub/Linux/utils/text/]
PTC: Prometheus TrueColor is a portable true color graphics system suitable for use in the creation of games, demos, emulators and other real time graphics software. It is especially useful as the framework for a 2- or 3-D rendering engine. PTC is a set of C++ classes that abstracts the platform-specific details of mode setting, surface handling, pixel format conversion and display updates. It allows you to write graphics code once and recompile without changing anything on all supported platforms. A feature not found in most other libraries is virtual display modes, which enable the programmer to work internally in 8-bit indexed color, RGB565 hilcolor or ARGB8888 true color independently of the display pixel format.
A source code distribution of PTC is available. It is currently (6/98) supported on DOS, Win32 and Linux under a wide range of C++ compilers, and support for X11, BeOS and Amiga is under development. Various documentation is available online.
[http://www.gaffer.org/ptc/]
pth: The GNU portable threads library is a POSIX/ANSI C based library providing non-preemptive scheduling for multiple threads of execution inside high-performance server applications. All threads run in the same address space, although each has its own run-time stack and program counter. The API is similar to the POSIX threads API in that threads can be spawned and joined. It differs in that the thread scheduling is done in a cooperative instead of preemptive manner. The threads are managed by a priority-and event-based non-preemptive scheduling mechanism, the goal of which is to achieve better portability and run-time performance. This event facility allows threads to wait until various types of events occur including file descriptor I//O, elapsed timers, raised signals, message port I/O, and thread and process termination. A source code distribution is available. This used to be called NPS.
[http://www.gnu.org/software/pth/]
pthreads: Pthreads is the POSIX 1003.1c threads standard put out by the IEEE standards committee. It is also the name of a software package obtainable at the given URL. See Nichols et al. (1996).
[http://www.mit.edu:8001/people/proven/pthreads.html]

ObjectThreads

A C++ wrapper library for pthreads.
[http://personal.nbnet.nb.ca/jnye/projects.html]
P3P: The Platform for Privacy Reference Project is an activity of W3C to enable Web sites to express their privacy practices and enable users to exercise preferences over those practices. Software written using P3P protocols will allow users to be informed of site practices, to delegate those decisions to their computer when appropriate, and to allow users to tailor their relationship to specific sites.
[http://www.w3.org/P3P/]
ptoc: A Pascal to C/C++ converter with a BGI emulation library. The goal is to produce readable and supportable code which preserves the style of the original code as much as possible. This recognizes Pascal dialects compatible with Turbo Pascal 4.0/5.0 and the ISO Pascal standard IEC 7185:1990(E) including conformant arrays. It has been (12/98) tested with Turbo, Oregon, Sun and HP Pascal implementations.
Ptoc can produce both C and C++ output, with the latter allowing the encapsulation of some Pascal types and constructions into C++ classes. This makes the mapping between Pascal and C++ more direct than between Pascal and C. C++ templates are used to implement Pascal arrays and files and special classes are used for conformant arrays. C++ streams are used to implement the Pascal I/O routines and the same runtime library is used for both targets. Various Turbo Pascal extensions such as units, strings and some special types and operations are recognized (but only for the C++ target). A source code distribution is available which has been successfully compiled with GCC. Documentation consists of a combination user's guide and reference manual.
[http://www.ispras.ru/~knizhnik/]
p2c: A Pascal to C translator.
[ftp://cs.caltech.edu/pub/]
[http://www.synaptics.com/people/daveg/]
Ptolemy: A software system upon which to build prototyping environments. Examples thus far of such environments include dataflow-oriented graphical programming for signal processing, discrete-event modeling of communication networks, and synthesis environments for embedded software. If you think about it, just about any sort of numerical or digital signal processing package is possible to implement with this system. After all, linear algebra and matrix operations are pretty much universal. The source code is available as well as binaries, including (I think) a Linux binary. Fair warning: This, like Khoros, is a *huge* package with a lot of documentation.
[http://ptolemy.eecs.berkeley.edu/]
PTool: A database tool providing persistence for data which supports the creation, storage, access and querying of complex objects. It is designed for high performance access to data and to scale as both the amount of data and the complexity of queries increase. PTool doesn't have the overhead of a general purpose object oriented database and thus is particulary well-suited for applications requiring high performance access to historical data. It is designed to query data distributed in a hierarchical storage system and is thus also well suited for data mining applications. It is also designed to query data in a multi-computer environment which makes it well suited for applications requiring numerically intensive queries.
The PTool design optimizes for high-performance access to historical data, provides a standard interface to IEEE compliant hierarchical storage systems, provides support for distributed data queries using message passing for loosely and tightly coupled clusters of workstations, supports uniform addressing of large amounts of data using 64 bit pointers, can be integrated in a modular fashion to existing scientific computing environments, and includes class libraries for scientific computing. The current (3/97) release is broadly ODMG compliant and the next major release is planned to be CORBA compliant.
The PTool distribution contains the source code including a variety of container classes, a series of pedagogical examples, tools for working with tabular data, and other tools including a basic tool for visualizing series data. The source code is set up to be compiled on Sun or IBM workstations, but I got it to compile with fairly minor modifications, i.e. removing the Sun and IBM specific include files from various programs.
[http://lac.uic.edu/LAC.html]
PTUI: The Python/Tkinter User Interface is a Python code development user interface consisting of an editor and an interpreter which can be embedded in larger applications or used by itself. It is an attempt to create an environment in which you can run code from within the Tk mainloop like in the wish interpreter, and uses a small framework of classes that can be embedded into a larger application to facilitate rapid development and testing.
The features of PTUI include:

automatic indentation and undo;

a modularization feature to communicate between buffers;

syntax highlighting;

an argument to execute an initialization script to change height, colors, fonts, etc.;

searchable online help;

an arbitrary object browser;

multiple buffers with individual namespaces;

usability as a frame which can be embedded in another application;

find/goto and comment/uncomment regions; and

built-in output and error windows.

A source code version of PTUI is available. Installation requires Python 1.4 or higher, Tkinter (part of the Python distribution), and Tcl/Tk (versions 7.4/4.0 through 7.6/4.2).
[http://starship.skyport.net/crew/zack/ptui/]
ptx: A GNU version of a traditional permuted index generator. It can handle multiple input files simultaneously, produce TeX compatible output, and produce KWIC (KeyWords In Context) indexes.
[http://www.gnu.ai.mit.edu/order/ftp.html]
PUB: The Paderborn University BSP library is a C library for supporting the development of parallel algorithms based on the Bulk Synchronous Parallel or BSP model. It offers buffered asynchronous message passing between nodes that is organized in supersteps. In each superstep a processor can work on local data and send messages, and at the end of the superstep a barrier synchronization takes place and all processors receive the messages sent in the previous superstep. PUB includes functions for both message passing and remote memory access. Some collective communication operations like broadcast and parallel prefix are also provided. Binary distributions are available for several types of platforms including networks of Linux Intel workstations. Documentation includes a user's guide in PostScript format.
[http://www.uni-paderborn.de/~bsp/]
publib: A library of generally useful C functions as well as a framework for building such a library from components provided by separate sources. This is an extension of the Standard C library. The components of the public library include:

xmalloc, functions for memory allocation;

dynarr, functions that make it easier to use dynamic arrays;

bitarr, functions for operating on bit arrays;

cfg, routines for reading and writing configuration files;

cmp, functions for comparing two array elements of a given type when given pointers to them;

expr, functions for evaluating arithmetic expressions given as a string;

fname, functions for manipulating POSIX-style filenames; and

stack, functions for operating on stacks.

A source code distribution is available. Documentation is mostly via man pages.
[http://liw.iki.fi/liw/programs/]
pup: The printer utility program is a GUI utility for maintaining printers under Linux. It currently (3/00) supports only Lexmark Optra Color 40 and 45 printers.
[http://pup.sourceforge.net/]
PUSE: The Portable UNIX Shell Environment is a set of Korn shell login environment files and nearly 80 ksh, Perl and Expect scripts for performing various tasks. The scripts include those involving text analysis and processing, file and directory analysis and processing, the system environment, printing and tape drives, disk space management, system monitoring, security, performance analysis, system configuration analysis and miscellaneous tasks.
The features of the ksh login environment files include:

an expanded shell prompt that can be set to any of several available formats and displayed in boldface or normal font;

preconditioning of the shell environment such that the standard environment variables are defined, e.g. $COLUMNS, $FCEDIT, $HISTSIZE, $MAILCHECK, etc.;

initialization of the TERM variable and stty options;

an option to alias vi to a script that will back up a file before running vi on it;

a predefined function for listing files sorted by access time in a long list format with access times instead of modification times;

predefined functions for a compressed-format listing of all files in a large directory or directory tree;

predefined functions for commonly-used options of the ls command; and

predefined aliases for commonly-used history commands.

[http://www.halcyon.com/www/starfire/puse/]
PUZZLE: A package for reconstructing phylogenetic trees from molecular sequence data by maximum likelihood which implements a fast tree search algorithm (i.e. quartet puzzling) that allows for the analysis of large data sets and automatically assigns estimations of support to each internal branch. It incorporates rate heterogeneity (invariable sites plus Gamma distributed rates) in all available substitution models (e.g. TN, HKY, and F84 for nucleotides; Dayhoff, JTT and mtREV24 for amino acids).
PUZZLE computes pairwise maximum likelihood distances as well as branch lengths for user specified trees. It offers a novel method, i.e. likelihood mapping, to investigate the support of internal branches without computing and overall tree. Other features include:

computation of clock-like branch lengths (and also for amino acides and non-binary trees);

an automatic likelihood ratio clock test;

the display of most probably assignment of rates to sites;

identifying groups of identical sequences;

reading multiple input trees;

the Kishino-Hasegawa test to check whether trees are significantly different;

the BLOSUM 62 model of amino acid substitution; and

application of SH model to 1st and 2nd codon positions.

PUZZLE is written in C and can be compiled and used on UNIX, VMS, Mac and MS-DOS platforms. It is documented in a user's manual available in both HTML and PostScript format.
[http://www.zi.biologie.uni-muenchen.de/~strimmer/puzzle.html]
PVaniM: A enhancement of PVM that produces animations of the execution of PVM applications. This is actually a couple of separate subsystems, one of which provides fine-grained, post-mortem visualizations of PVM applications, and the other which provides on-line, low-overhead, minimal perturbation visualizations. Both are built on top of the POLKA visualization package and can be used on packages with both POLKA and PVM installed.
[http://www.cc.gatech.edu/gvu/softviz/parviz/parviz.html]
PVFS: The Parallel Virtual File System is a project to explore the design, implementation and potential uses of parallel I/O. PVFS is designed for use in environments consisting of workstation clusters and consists of a set of daemons and a library of application interface calls that operate on top of an off-the-shelf operating system using standrd network protocols for communication. The features include:

file striping;

file partitioning;

collection I/O;

application-oriented interfaces; and

a stream-based data transfer mechanism which attempts to improve throughput by reducing the number of control messages and removing stripe and partition dependence on message sizes.

The application interfaces currently (2/99) supported include:

UNIX-style I/O with file partitioning;

multidimensional block I/O;

UNIX-style collective I/O; and

2-D collective I/O for common block decompositions.

This is available in source code and RPM formats. Documentation includes a user's guide and some technical papers.
[http://ece.clemson.edu/parl/pvfs/]
PVM: The Parallel Virtual Machine) software is a package that enables a collection of heterogeneous computers to be used as a coherent and flexible concurrent computational resource. PVM is an integrated set of software tools and libraries which emulates a general-purpose, flexible, heterogeneous concurrent computing framework on interconnect computers of varied architecture. The system consists of two parts: a daemon called pvmd which resides on all computers comprising the virtual machine, and a library of PMV interface routines containing a functionally complete repertoire of primitives needed for cooperation between the tasks of an application. PVM currently (5/97) supports C, C++ and Fortran language interfaces. The C and C++ language bindings are implemented as functions while the Fortran bindings are implemented as subroutines
The principles upon which PVM is based include:

a user-configured host pool containing a list of computers upon which computational tasks can be performed which can be added to and deleted from before or during operation;

translucent access to hardware where application programs may view the hardware environment either as an attributeless collection of virtual processing elements or can exploit the capabilities of specific machines in the host pool by positioning specific tasks on the most appropriate machines;

process-based computation in which the basic unit of parallelism is a task, i.e. an independent sequential thread of control which alternates between communication and computation;

an explicit message-passing model in which collections of computational tasks perform the workload for an application using data-, functional-, or hybrid-decomposition and cooperate by explicitly sending and receving messages to one another;

heterogeneity support in terms of machines, networks, and applications; and

multiprocessor support wherein PVM uses the native message-passing facilities on multiprocessors to take advantage of the underlying hardware.

The January 1998 issue of the Linux Journal contains an article on using PVM with Linux.
Packages which use or enhance PVM in some way include:

ADAPTOR, an HPF compilation system which transforms HPF code into PVM calls;

Adsmith, an object-based DSM system built on top of PVM;

A++/P++, a set of C++ classes for numerical computations with structured grids;

BLACS, a version of BLAS for message passing systems;

BSPlib, a library implementing the BSP model of parallel computation;

CG, a conjugate gradient package for the iterative solution of linear systems;

CHARM, a parallel programming system;

CL-PVM, a Common Lisp interface to PVM;

CODE, a visual programming system for turning sequential into parallel programs;

Condor, an environment for managing very large collections of distributed workstations;

Converse, a parallel programming framework for developing portable programs;

COSMICS, a set of Fortran programs for cosmological modeling;

C*, an explicitly parallel version of C;

CUMULVS, an infrastructure library that allows data to be extracted from running parallel simulations and visualized;

DOM, a radiative transfer model for remote sensing applications;

Dome, a C++ library of distributed objects for parallel programming;

DPMTA, a library for implementing various multipole algorithms for N-body simulations;

DQS, a distributed queueing system;

DSU, a seismic applications toolkit;

EGO, for performing calculations in molecular dynamics;

Emu/fdtd, an electromagnetics simulator;

FASTA, tools for biological sequence analysis;

fsolver, a solver for the incompressible Navier-Stokes equations;

GALOPPS, a flexible genetic algorithm package;a

GHC, a Haskell language environment;

GLU, a high-level system for granular data-parallel programming;

HPF, a set of extensions to Fortran to support parallel programming;

JavaPVM, a Java interface to PVM;

jPVM, another Java interface to PVM;

KLIC, an implementation of the concurrent logic programming language KL1;

LASSAP, a parallel sequence analysis package;

LPARX, provides support for scientific calculations involving particle and adaptive multilevel finite-difference methods;

Maisie, a simulation language for the sequential and parallel execution of discrete event simulation models;

mEDA-2, a PVM extension providing virtual shared memory for intertask communication and synchronization;

NAMD, an object-oriented molecular dynamics package;

Pade, a system for developing parallel applications for heterogeneous networked computers;

Parallaxis, a structured programming language for data parallel programming SIMD systems;

Para++, C++ classes for encapsulating message passing primitives into a higher level of abstraction;

PCCM, a parallel version of the Community Climate Model;

Perl-PVM, a Perl extension for PVM;

PFSLib, a library offering parallel access to files for parallel applications;

PICL, a library implementing a message passing interface;

PIM, Fortran routines for solving systems of linear equations;

PIPS, a data conversion package;

PIOUS, a complete parallel I/O system for PVM;

PLUS, allows interoperation with MPI and PARIX;

PM2 High Perf, a portable multithreaded for highly parallel applications;

POV-Ray, a parallel ray tracing package;

ppmake, a parallel make utility;

PRM, a manager for running applications on a network of workstations;

Proteus, a rapid prototyping system for developing parallel algorithms;

P-SPARSLIB, tools for solving large, sparse linear systems on distributed memory computers;

PSTSWM, a benchmark spectral transform shallow water model code;

PVaniM, a PVM extension that produces animations of the execution of applications;

REGAL, a distributed genetic algorithm package;

ScaLAPACK, for performing dense and band linear algebra computations on distributed memory computers;

SEA, an ocean circulation model;

Surface Evolver, for studying surfaces shaped by surface tension and other energies;

tclpvm, a set of PVM extensions to Tcl;

Tkpvm, a Tcl/Tk interface to PVM;

TPVM, a threads-oriented subsystem for PVM;

TRAPPER, a graphical programming environment;

VIC, a package for describing CFD algorithms in data parallel fashion;

VPE, a visual parallel programming environment;

WAMM, a graphical tool for handling repetitive administration tasks; and

Xi, an interactive programing language with vector extensions.

PVM supports a wide variety of platforms (including those running Linux) that may be interconnected by a variety of networks. Extensive documentation is available, including a PostScript file of a recently published book about PVM. See Alexandrov and Dongarra (1998) and Geist et al. (1994).
[http://www.epm.ornl.gov/pvm/pvm_home.html]

pypvm

A Python module for accessing the PVM C libraries.
[http://www.flyn.org/]

TPVM

Threads-oriented PVM is an experimental subsystem for PVM which supports the use of light-weight processes or threads as the basic unit of scheduling and parallelism. TPVM is designed for ease of portability with the changes required for a different platform, OS, or threads implementation isolated in a single module. The thread model overcomes several of the disadvantages of a process-oriented model, principal among which are task initiation and scheduling costs, overlapping computation and communication on a single processor, smaller granularity, exploiting small-scale SMMPs, and supporting event- or data-driven active message based computation.
[http://www.cs.virginia.edu/~ajf2j/tpvm.html]
PVODE: A package of three closely related equation solvers:

PVODE, for systems of ODEs;

LINSOL, for systems of nonlinear algebraic equations; and

IDA, for systems of differential-algebraic equations (DAEs).

The solvers have some code modules in common, chiefly a module of vector kernels and linear system solver based on a scaled preconditioned GMRES method.
PVODE - an extension of a sequential solver package called CVODE - is a solver for large systems of ODEs on parallel machines. It contains methods for solving both stiff and non-stiff IVPs, with several integration methods including the variable coefficient forms of the Adams and Backward Differentiation Formula methods. The implicit time step linear systems are solved via iterative, preconditioned Krylov solvers with the preconditioner either user-supplied or one included in the PVODE package. This is written in C although callable from either that or Fortran, and the parallelization is handled via calls to MPI.
The closely related KINSOL solver for nonlinear algebraic equations uses inexact Newton methods with line search strategies for accelerated convergence. Both serial and parallel versions are available. The IDA solver uses backward differentiation formula methods to solved DAEs and is also available in serial and parallel versions. The serial version includes both direct and iterative (GMRES) methods for solving linear systems, while the parallel version includes only the latter.
The entire PVODE package is being incorporated into PETSc. An overall user guide and documentation for each component are available in PostScript format.
[http://acts.nersc.gov/pvode/]
[http://www.llnl.gov/CASC/PVODE/]
PVRG-JPEG: A fairly complete JPEG baseline package targeted toward simulation and research (where a baseline system is defined as the minimal system needed to claim JPEG compatibility). The system includes a flexible encoder which can generate compressed files through different valid strategies which can also decode all possible JPEG baseline compressed files.
The source code for PVRG-JPEG, written in C, is available and can be compiled on most generic UNIX systems with a C compiler. The package is documented in a 55 page PostScript technical manual and user's guide.
[ftp://havefun.stanford.edu/pub/jpeg/]
PVS: A verification system, i.e. a specification language integrated with support tools and a theorem prover. It is intended to capture the state-of-the-art in mechanized formal methods and to be sufficiently rugged to be used for significant applications. The PVS system consists of a specification language, a number of predefined theories, a theorem prover, various utilities, documentation, and several examples from a variety of application areas. PVS has thus far been chiefly applied to algorithms and architectures for fault-tolerant flight control systems and to problems in hardware and real-time system design.
The PVS language is based on classical, typed higher-order logic with base types including uninterpreted types that may be introduced by the user as well as built-in types such as booleans, integers, reals, and the ordinals. Type constructors include functions, sets, tuples, records, enumerations, and recursively-defined abstract data types such as lists and binary trees. The theorem prover provides a collection of powerful primitive inference procedures which are applied interactively under user guidance wihtin a sequent calculus framework. The inferences include propositional and quantifier rules, induction, rewriting, and decision procedures for linear arithmetic, with the implementations thereof optimized for large proofs. PVS uses Emacs to provide an integrated interface for the language and prover. Extensive help, status reporting, and browsing tools are available as well as the capability of typesetting specifications in LaTeX. Proof trees and theory hierarchies can be displayed graphically using Tcl/Tk.
PVS is implemented in Common Lisp and runs on most workstations with a Common Lisp compiler with an integrated CLOS. It is supported on Sun SunOS and Solaris, IBM AIX, and Linux Intel running Redhat 4.0 or greater. A plethora of manuals are available for PVS, all in PostScript format. These include an overview, a quick reference, a language manual, a system manual, a prover manual, a tutorial, and more. The package are freely available via the Web but a license agreement must also be signed to use it. Full use of this package requires Emacs, Tcl/Tk and LaTeX.
[http://pvs.csl.sri.com/]
pw: A VRML parser library written in Java.
[http://www.iicm.edu/vrwave/pw]
pWEB: A parallel Web server harness which provides a request-forwarding context-switching infrastructure for building HTTP services over a cluster of workstations. Popular servers like Apache, NCSA, Spinner, Plexus, etc. can be hooked up onto the harness for parallel processing HTTP requests. This provides the most benefit on workstation clusters with fast interconnects like ATM or on distributed memory parallel computers, although it can be used over ethernet connections. Advantages which can be derived from pWEB include load balancing (i.e. CPU intensive CGI requests can be distributed across workstation nodes) and distributed file I/O (i.e. file access congestion can be decreased by directing file requests to a specific node's local disk).
The pWEB package includes the source code which is written in C. The Makefile includes parameters to compile on UNICOS, SGI IRIX, IBM AIX, Sun Solaris and SunOS, DEC OSF/1, and Linux systems. The documentation is included in the package and is also available online.
[http://phobos.nsrc.nus.sg/STAFF/edward/pweb.html]
PXI: A program developed to allow for the convenient visualization of n-dimensional econometric data which is useful for displaying all types of data. PXI offers publication quality output, a convenient graphical user interface (GUI), and powerful data manipulation features. The features of PXI include:

graph annotation in a variety of fonts;

fitting experimental data including the plotting of the likelihood function, various tokens to annotate each data point, and the numerical annotation of data points;

a built-in algorithm for generating complete quantal response correspondence for normal form games;

a choice of graph types including each data column plotted against the dependent variable on a rectangular grid,

two data columns plotted on a triangular grid to simulate 3-D graphics, and

one data column plotted against another.

PXI is a shareware package with binaries available for MS Windows, Sun SunOS and Solaris, HP-UX, IBM RS/6000, and, upon request, Linux platforms.
[http://www.cco.caltech.edu/~egrayver/pxi.html]
P-XSC: Pascal eXtension for Scientific Computation is a version of Pascal that significantly simplifies scientific and technical programming. It is particularly well suited for the development of numerical algorithms that deliver highly accurate and automatically verified results. The features of P-XSC provide:

a large number of predefined data types with arithmetic operators

predefined, highly accurate functions for real and complex numbers and intervals as well as for the corresponding vectors and matrices;

modules for dividing programs into smaller units;

an operator concept;

functions and operators of arbitrary result type;

overloading of functions, procedures and operators;

dynamic arrays;

access to subarrays;

rounding control by the user; and

accurate evaluation of expressions.

P-XSC contains Standard Pascal and is thus usable for generic Pascal programming tasks as well.
Source code and binary versions of a P-XSC compiler are available, with one of the latter being for Linux Intel platforms. A compiler manual is available in PDF format.
[http://www.xsc.de/PASCAL-XSC/pascal-xsc.html]
pyclimate: Tools for climate data analysis that make extensive use of NumPy. The package contains:

I/O functions for handling ASCII and NetCDF formats;

time handling routines to convert between date and Julian day;

an interface to the DCDFLIB library of statistical functions;

empirical orthogonal function analysis routines based on the singular value decomposition (SVD);

routines for calculating the SVD;

a multivariate digital filter based on the Kolmogorov-Zurbenko and Lanczos filters;

kernel-based probability density functions; and

differential operators on the sphere.

[http://lcdx00.wm.lc.ehu.es/~jsaenz/pyclimate/]
pyCliff: A Python modoule implementing geometric or Clifford algebras, i.e. an algebra of vectors of given dimensions and signature. In Clifford algebra the inner (dot) and outer products (the latter a generalized relative of the 3-D cross product) are unified in an invertible geometric product. Scalars, vectors and higher-grade entities can be mixed freely and consistently in the form of mixed-grade multivectors.
[http://starship.python.net/crew/kernr/Projects.html]
Pydb: A modified form of the standard Python debugger pdb with augmented features making it suitable for use with DDD. The changes required for the port added some new features to pdb including temporary breakpoints, conditional breakpoints, an ignore breakpoint count, and an easier way to set breakpoints in modules outside the current one. Source code distributions are available.
[http://daikon.tuc.noao.edu/python/]
Pyfort: A tool for connecting Fortran routines to Python. Pyfort translates an input file describing the Fortran functions and subroutines to be accessed from Python into a C language source file defining a Python module.
[http://pyfortran.sourceforge.net/]
PyNG: The Python Network Grapher is a tool designed to give visible insight into network usage. It summarizes network traffic flow through a GUI and plots a usage graph for the current day as well as overviews for the week, month, and year.
[http://www.cb.hva.nl:81/PyNG/]
PyOpenGL: A Python interface to the OpenGL widget set.
[http://www.python.de/]
PyrTools: A collection of Matlab tools for multi-scale image processing. The PyrTools set includes programs for: recursive multi-scale image decompositions including Laplacian pyramids, QMFs, wavelets, and steerable pyramids to operator on 1-D or 2-D signals of arbitrary dimension; fast 2-D convolution routines with subsampling and boundary handling; fast point operations, histograms, and histogram matching; fast synthetic image generation; and display routines for images and pyramids.
[ftp://ftp.cis.upenn.edu/pub/eero/]
pysimplex: A Python package of mixed integer linear programming modules that provides basic symbolic programming tools for constructing, solving and optimizing systems of linear equations and inequalities. It includes an implementation of the classic simplex linear optimization algorithm as well as a filter for parsing and optimizing linear models encoded using the standard MPS format. This requires the NumPy set of numerical extensions for Python.
[http://www.pythonpros.com/arw/pysimplex/]
Python: An interpreted, interactive, object-oriented programming/scripting. It has modules, classes, exceptions, high level dynamic data types, and dynamic typing along with interfaces to many system calls, libraries and various windowing systems (e.g. X11, Motif, Tcl/TK, Mac, MFC, STDWIN). New modules are easily written in C or C++, and it is usable as an extension language for applications that need a programmable interface.
The source code is available and easily installable on UNIX platforms, and binaries are available for many platforms including Linux. A nicely done Python Tutorial can be found at UnixWorld Online. The Jan. 1996 issue of the Linux Journal has an introduction to Python by Jeff Bauer. A project to develop a matrix language called Numerical Python is well under way as of 7/96. See Lutz (1996) and Watters et al. (1996).
Related packages which are written in, extend or use Python in some way include: Apache, Bobo, BSCW, Chautauqua, FastCGI, Fnorb, Gadfly, Grail, GraphApp, Guile, HTMLgen, ILU, JPython, Mailman, Maxtal Interscript, Medusa, MMTK, mSQL, mxODBC, NSAPY, NumPy, Paos, PIL, Pipermail, Pmw, PTUI, Pydb, PyEphem, PyGreSQL, PyGTK, PyNG, PyOpenGL, PythonNetCDF, PyXForms, Rivet, SAML, SNMPY, SWIG, SYLU, Wafe, Wily, WPY, wxPython, X-extension, and zlib.
[http://www.python.org/]
[http://starship.skyport.net/]
[http://starship.skyport.net/crew/amk/cookbook/faqw.cgi]

Distutils

A set of utilities providing a standard mechanism for building, distributing and installing Python modules or multi-module distributions. The Distutils provide a set of classes to implement the normal tasks involved in such work, e.g. building C extensions, processing documentation, installing libraries, compiling files to bytecode, etc. It also provides a standard way for module developers to give users access to these classes via a simple Python script.
[http://www.python.org/sigs/distutils-sig/]

PIL

The Python Imaging Library adds an image object to the Python interpreter. This allows loading image objects from a variety of file formats as well as applying a large set of image operations to them.
The operations which can be performed using the PIL objects include: color manipulations including bilevel, greyscale, palette, true color (RGB), true color with transparency, and color separation (CMYK); copying, cutting, and pasting; transparency; channel and point operations; color transforms including matrix operations; and image enhancement including convolution filters. File formats which can be opened, loaded, and saved are: BMP, EPS (with Ghostscript), GIF, IM, JPEG, MSP, PNG, PPM, TIFF and XMB. Read only formats are CUR, DCX, FLI, FLC, GBR, GD, ICO, IMT, PhotoCD, PCX, PSD, TGA, SGI, SUN, and WMF, and save only formats are PDF and EPS (without GhostScript).
PIL can be installed on most platforms which support Python. Full functionality requires the aforementioned Ghostscript as well as the IJG JPEG library and the ZLIB library. The package is documented in a 40 page manual in PostScript format.
[http://www.python.org/sigs/image-sig/Imaging.html]

Python2C

A Python to C translator that attempts to speed up Python code by removing a significant fraction of the CPython virtual machine (VM) overhead.
[http://lima.mudlib.org/~rassilon/p2c/]
PyXForms: A package that basically binds together the Python interpreted language and the XForms GUI builder. This faciliates the quick and easy construction of GUIs on many UNIX/X Window platforms. It is object oriented, extensible, and allows the non-graphic portions of the program to be written in Python, C or C++.
[http://ultra7.unl.edu.ar/pyxforms]

[ home / linux ]

Next: Qa-Qm Up: Linux Software Encyclopedia Previous: Pa-Pm Contents

Manbreaker Crag 2001-03-08