Pa-Pm

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

Last checked or modified: Mar. 4, 1997

[home / linux ]

 

Paai's Text Utilities

A collection of programs and scripts for manipulating text files. They were written by a chap engaged in information retrieval and corpus linguistics. All of them depend on the availability of a weighted index which can be generated by either the SMART package or by the discrim program listed. The programs comprising PTU are:

• chain, which tracks chains of words in texts;
• sent_wgt, which takes a weights file and a text file and prints sentence weights;
• sent_til, which prints sentence number and 2-sentence similarities;
• discrim, which computes the discrimination value of words in text files;
• bigrams, which computes the approximate mutual information for bigrams;
• listwords, which creates lists of words from text files;
• matrix, which creates a cross-tabulated file from a SMART index file;
• wordsel, which extracts word-file combinations from a cross-referenced file;
• arg-expand, which expands a range, e.g. a,c-f,..., to a,c,d,e,f,...'
• arfftosvd, which converts an arff file to the input format of svdinterface;
• de-matrix, which inverts the effects of matrix;
• docvec, which creates a vector representation of documents in the Reuters database;
• rocchio, which computes the centroid of positive and negative classes;
• simil, which compares every vector in a file with a query and writes the results;
• smallsmart, which computes word-document weights according to the atc variant of SMART;
• smarttosvd, which converts a three column index to the sparse matrix format used for svd;
• splitname, which cuts a filename in substrings;
• svdtoarff, which converts the output of svdinterface to a rectangular interface; and
• doenuplot, a simple front-end for Gnuplot.

A source code distribution of PTU is available. The programs are written in C and in shell scripts and were developed on a Linux Intel box. All are documented in individual man pages.

[http://pi0959.kub.nl:2080/Paai/Publiek/]

 

Pacco

Pavia's Active Component Compound Objects is an object-based approach to data processing which is an extension of Tcl and a set of widgets which extend the Tk toolkit to support object visualization. The features of Pacco include: a highly dynamic environment where new processing functions or new types of objects can be auto-loaded at run-time; a two-language approach so a command language (Tcl) can be used for most of the work while critical details can be programmed in C; an object model where complex objects can be specified and updated at run-time by grouping basic components; the seamless blending of the programming model for data processing with the model for the graphical interface; access to low-level features in a high-level way for the easy creation of shared or memory-mapped objects; the smart loading of files in foreign formats; object visualization at different levels of customization from highly automated to highly configurable; and more. A generic Pacco viewer (gpv) has been written using the library and is additionally available.

The source code for Pacco is available. Installation and use require Tcl 7.3 or later and Tk 3.6 or later, depending upon the version of Pacco which is used. The package is documented online and in files included in the distribution.

[http://iride.unipv.it/pacco/Index.html]

 

PACT

The Portable Application Code Toolkit is a comprehensive, integrated, and portable software development environment created for applications having unique requirements not met with available software. It defines a single, high-level programming interface that shields developers from different hardware architectures and operating systems. PACT is ideal for developing portable numerical simulation, applied science and engineering software, with such features as a comprehensive set of tools for developing portable applications, rapid prototyping, portable and efficient binary data handling, graphics system interface to several systems (X Windows, QuickDraw, DOS, PostScript, CGM), support for developing customizable GUIs, portable interprocess communication and control for single CPUs, networks and parallel machines, a portable mathematics library, extensive support for generation, runtime, and post-processing phases of numerical simulation codes, a portable Scheme dialect for user extensibility, extensive signal processing functionality, portable and high-level color graphics rendering, and tools for browsing, intelligent comparison, and graphical display of the contents of binary data and picture files. The component parts of PACT are:

• PANACEA, a library of routines to handle data flow controls, I/O mechanisms, and database management issues which are generic to all simulation codes;
• PDBLib, a library of file management routines used for storing and retrieving data in a portable format, i.e. PDB;
• PDBDIFF, a tool for comparing the contents of two PDB and displaying the differences;
• PDBView, a tool for interactively browsing through a PDB file displaying the contents graphically or textually;
• PGS, an application program interface (API) for graphics which is independent of the underlying host graphics system which supports line and text drawing primitives, line and text attributes, bit maps for handling images, and several rendering algorithms;
• PML, a Portable Mathematics Library containing many math routines such as equation solvers as well as structure definitions and related functions provided to aid C programmers in organizing computations in a mathematical way;
• PPC, a Portable Process Control library to execute and communicate with other processes in environments which permit such operations;
• SCORE, the core foundation of PACT containing functions to smooth over differences between different C implementations as well as several function groups which are used extensively throughout the system;
• SX, the PACT implementation of the Scheme language; and ULTRA, a program for the presentation, manipulation, and analysis of 1D data sets, i.e. X-Y pairs.

The source code is available and has been tested on AIX, HP-UX, Irix, Linux, MAC, OSF, SunOS, Ultrix and Unicos systems. A huge amount of documentation is available in the form of user manuals for all of the PACT program components available in both PostScript and HTML format.

[http://www.llnl.gov/def_sci/pact/pact_homepage.html]

 

PADE

The Parallel Applications Development Environment is a system for facilitating the development of parallel applications for heterogeneous networked computers. It can employ any standard message-passing library for interprocessor communications, but since its main purpose is development on heterogeneous platforms the current versions uses the PVM message passing library. It provides a single GUI which incorporates all of the essential tools for the development of parallel applications. PADE incorporates a program organizer, a parallel make utility, utilities for running PVM programs, access to standard editors, debuggers, and performance monitors, and a graphical interface to the structure of the virtual machine. The features of PADE include: starting a project either from scratch or by reading a configuration file saved from a previous run; collecting all the data required to send files to all specified nodes of the virtual machine; allowing the u ser to edit any specified source file on the development host; starting PVM; saving project data in a configuration file; creating a PVMmake configuration file containing the files and commands to send to each node; executing programs and UNIX commands; and providing for the smooth completion of a program, e.g. terminating stray spawned processes and cleaning up temporary files on each node.

The source code for PADE is available. The installation and use of this on a UNIX/X11 development host also requires PVM and Tcl/Tk. The documention consists of user's and installation manuals available in HTML and PostScript format.

[http://www.itl.nist.gov/div895/pade/]

 

PadFEM

An object-oriented environment supporting and implementing parallel adaptive finite element simulations in 2- and 3-D. PadFEM includes preprocessing GUIs based on both Tcl/Tk and Java, quadtree/octree-based mesh generators for 2- and 3-D arbitrary domains, mesh partitioning algorithms, different solvers, error estimators, and mesh refinement and load balancing algorithms. An Xlib-based GUI called XFem is provided for monitoring, debugging, and postprocessing in 2-D. A 3-D version used OpenGL. The parallelization model used by PadFEM is SPMB based on mesh partitioning. The object-oriented data structure automatically generates halo elements to provide one-element-wide virtual overlap at inner boundaries. Adaptivity is supported by functions for inserting nodes, edges, faces and elements. Load balancing algorithms use built-in procedures to transfer elements. Included solvers include multigrid, conjugate gradient, and domain-decomposition based preconditioned conjugate gradient solvers. The FEM module allows the solution of stationary and nonstationary Poisson equations with mixed boundary conditions, and will soon (5/98) have the capability of solving the Navier-Stokes equations.

A distribution is not available as of 5/98, but is promised as soon as the documentation is considered sufficient for general release.

[http://www.uni-paderborn.de/cs/padfem/]

 

Pad++

A package which explores multiscale interfaces, i.e. those in which zooming and panning are a fundamental part of the user's interaction with the computer. Zooming and panning are powerful visualization tools for any kind of hierarchical data, i.e. nested details can be shown at a smaller scale to show their relationship to large objects and the zoomed upon to see their details. They are also techniques that can be applied to file and Web browsers wherein subdirectories or subdocuments can be preserved as one navigates below or above them. Pad++ has capabilities other than just panning and zooming, e.g. portals or holes through which other regions on the same or another Pad++ surface can be viewed, turning any object into a hyperlink, making objects sticky so they ``stick'' to the surface of the glass and remain stationary while the rest of the objects on the Pad++ surface move around (which can be used to create automatic hyper-buttons which float above the Pad++ surface), and portal filters (or magic lenses) which filter what is seen through them. The Pad++ distribution consists of C++ code implementing a Tcl/Tk Pad++ widget and a Paddraw application which uses the widget. A version of the Tcl wish shell with Pad++ built-in can be compiled and used to create zoomable interfaces. It is available as source code or in binary format for SGI IRIX, IBM AIX, Sun SunOS and Solaris, and Linux Intel platforms. Further work is being done on a Pad++ Web browser, creating Pad++ GUI components, developing Pad++ applications for understanding large datasets, and more. Manuals for both Pad++ and Paddraw are available online and as helper applications within the software.

[http://www.cs.unm.edu/pad++/]

 

PADRE

A C++ class library supporting distributed data management and communication that provides for various distribution mechanisms via underlying distribution libraries. PADRE seeks to provide a uniform distributed data management interface in the presence of a multiplicity of distribution libraries, a choice of communication libraries, a choice of execution models, varied computational/communication patterns, and a variety of architectures. It also enables better performance than can be obtained when restricted to the use of a single distribution library since it supports the simultaneous use of more than one such library. [http://www.c3.lanl.gov/PADRE/]

 

paintlib

A C++ class library for image coding and manipulation. It supports the PNG, TGA, TIFF, JPEG/JFIF, Windows BMP, and Mac PICT formats. The PNG, TIFF, and JPEG decoders are based on libpng, libtiff, and libjpeg, respectively. Data source and destination formats can be tailored as necessary. Additionally, format-independent but fast bitmap manipulation classes are available. A source code distribution is available. [http://user.cs.tu-berlin.de/~uzadow/paintlib/]

 

PAM

Pluggable Authentication Modules are really spiffy. The December 1997 issue of the Linux Journal contains an article about PAMs.

 

PAMELA

PerformAnce ModEling LAnguage is a project to develop a modeling methodology which yields fast, parameterized performance models of parallel programs running of shared- and distributed-memory machines. PAMELA is also a performance simulation language which supports a procedure-oriented modeling paradigm, i.e. the application and machine are modeled in terms of a PAMELA source description and then a compile-time analysis method is used in which a PAMELA model is automatically compiled into an explicit analytical performance model. This method allows low cost and fully parameterized performance models to be derived which can be used for automatic system optimization and scalability analysis. A PAMELA compiler is available which translates PAMELA models to C which is linked to a PAMELA run-time system library, a simple, standalone, discrete-event library based on light-weight threads. The compiler translates PAMELA models to both analytic performance models and simulation programs. The compiler is written in ANSI C and can be compiled on generic UNIX platforms with an appropriate compiler. The system is documented in a set of technical reports available in PostScript format.

[ftp://dutepp0.et.tudelft.nl/pub/gemund]
[http://dutepp0.et.tudelft.nl/~gemund/Pamela/pamela.html ]

 

PAML

The Phylogenetic Analysis by Maximum Likelihood package is for the phylogenetic analyses of DNA or protein sequences using the method of maximum likelihood (ML). It can be used to estimate the branch lengths in a phylogenetic tree and model parameters in the evolutionary model such as the transition/transversion rate ratio, the shape parameter of the gamma distribution for variable evolutionary rates among sites, and rate parameters for different genes. It can also be used to test hypotheses concerning sequence evolution, calculate substitution rates at sites, reconstruct ancestral nucleotide sequences, simulate nucleotide sequence data sets, and reconstruct phylogenetic trees via maximum likelikhood and Bayesian methods. The programs in the PAML package are:

• baseml, for ML analysis of nucleotide sequences, estimation of tree topology and branch lengths and substitution parameters under a variety of nucleotide substitution models, constant or gamma rates for sites, etc.;
• codorml, for ML analysis of protein-coding DNA sequences using a codon-based model, calculation of the codon-usage table, and estimation of synonymous and nonsynonymous substitution rates;
• aaml, for ML analysis of amino acid sequences under several amino acid substitution models, constant or gamma-distributed rates among sites, among-gene and within-gene variation of substitution rates, etc.;
• pamp, for parsimony-based analyses for a given tree topology, estimation of the substitution pattern, estimation of the gamma parameter for variable rates among sites by the method of moments, etc.
• mcmctree, for Bayesian estimation of phylogenies using DNA sequence data and Markov chain Monte Carlo calculation of posterior probabilities of trees; and
• listtree, for listing all rooted and unrooted trees for a given number of species, generating random trees with branch lengths from birth-death process with species sampling, calculating tree bipartition distances, etc.

A source code distribution of PAML is available. All programs are written in ANSI C and should be portable to any platform with an appropriate compiler. The documentation is, unfortunately, in Microshaft Word format.

[http://abacus.gene.ucl.ac.uk/ziheng/paml.html]

 

PANDA

A project to produce new data management techniques for I/O intensive applications that will be useful in high performance computing. A specific task is to examine the problem of efficient support for applications that make use of extremely large multidimensional arrays on secondary storage. The goals of the project are to provide simpler and more abstract interfaces to application programmers, to produce more advanced I/O libraries supporting efficient layout alternatives for multidimensional arrays on disk and in main memory, and to support high performance array I/O operations. A source code for PANDA, written in C++, is available and can be compiled and used on distributed memory parallel architectures, networks of workstations, and sequential workstations. Of chief interest to Linux users is that it currently runs on the UNIX file system using the MPICH implementation of the MPI message passing library. The documentation is available separately in PostScript format. See also HDFNOW. See Seamons and Winslett (1996).

[http://bunny.cs.uiuc.edu/CDR/panda/]

 

Pandora

A package which lets the managers of Majordomo mailing lists subscribe and unsubscribe users, manage archive files, and change list configurations via the Web. Pandora is designed to be usable at a screen size as low as 640x480 as well as with Lynx. It makes extensive use of tables, although non-table users can still get a clear and readable display. The package is highly configurable including such things as syslog levels, page coloring, menu options, computer aliasing, and more. [http://rodau.ed.umuc.edu/pandora/]

 

Panorama

A framework for creating, rendering and processing 3-D images that can read a description from a file in any of several supported scene formats and output an image file into any of several graphics formats. Panorama is intended to become a complete system with several supported input and output formats and renderers. The features of Panorama include:

• a plug-in architecture in which components are loaded as needed and which is easily extensible;
• an object-oriented scene description language with classes, inheritance and other OO features (which is itself a plug-in);
• support for ray tracing with other rendering methods to be added;
• a postprocessing system that lets filters be applied to images after their generation;
• an object filter attribute in each object that lets a filter be specified for application on an object basis; and
• a bidirectional scattering distribution function (BSDF) for materials that encapsulates their properties with respect to light.

A source code distribution of Panorama is available as is a binary distribution for Linux Intel platforms. Compilation requires GCC version 2.8.1 and glibc 2.07. Documentation is as yet (5/98) a bit sketchy.

[http://www.vnet.es/~ajimenez/panorama.html]

 

Paos

The Python active object server is an active multi-user object server with a simple query language. The distribution consists of modules which: implement the storing and locking of objects, the query language, and the registration of notifications; implement the network interface of the server; implement the network interface of a client; define a class in which all objects to be stored on the server need to be; implement a number of utility functions. Example modules are included which: implement a producer that accepts and stores lines to the server; implement a consumer that prints out lines produced by a producer; and implement two-way communication. A source code distribution of the Python modules which comprise the package is available. [http://www.cs.colorado.edu/~carlosm/software.html]

 

PAPERS

Purdue's Adapter for Parallel Execution and Rapid Synchronization is specialized hardware which connects unmodified platforms running UNIX or Linux to make a fine-grained parallel computer. The hardware can be built or bought (rather cheaply) and can be much more effective than using conventional networks of workstations with, e.g., message passing software, since PAPERS cluster even support SIMD and VLIW execution modes. PAPERS clusters are programmed using a library called AFAPI (the Aggregate Function Application Program Interface). Programs are written using the AFAPI library with C or C++, compiled with gcc, and then executed on a PAPERS cluster (with future plans including PAPERS compilers for parallel C dialects and an automatic parallelizing Fortran compiler). Two software implementations of AFAPI are currently (5/97) available. SHMAPERS (SHared Memory Adapter for Parallel Execution and Rapid Synchronization) implements the full user-level AFAPI for SMP and uniprocessor Linux/UNIX systems which provide the standard System V shared memory segment operations. SHMAPERS is entirely bus-lock free which enhances portability and ensures minimal bus interference during spin-lock operations. CAPERS (Cable Adapter for Parallel Execution and Rapid Synchronization) implements AFAPI for precisely two *86-family PCs running Linux.

[http://garage.ecn.purdue.edu/~papers/]

 

PAPyRUS

A world processor for UNIX systems under X11/Motif. The goal of this project is to create a complete and modern word processor for document composition. It presently features a good range of functionality but is still in development. The three modules that comprise PAPyRUS are a the kernel written in C++, a TCL command interpreter, and a GUI written in C using the X11/Motif library. The presently available functions include text insertion, image insertion (via the XPM format), a command language, modification of character and paragraph attributes, several save formats (ASCII, PostScript, PAPyRUS format), document printing, and a syntax checker (i.e. ispell).

The source code is available as well as statically and dynamically linked Linux binaries. The documentation is contained within a 130 page manual in PostScript format. It is also only available in French at present (2/97).

[http://or.mime.univ-paris8.fr/~loscar/Papyrus/
papyrus_eng.html]

 

Parallaxis

A structured programming language for data-parallel programming (SIMD) systems. It is based on sequential Modula-2 but extended with machine-independent parallel constructs. In Parallaxis an abstraction is achieved by declaring a processor configuration in functional form, specifying number, arrangement, and connections between processors. With these "virtual processors and connections", an application program can be constructed independent of the actual computer hardware. The system consists of compilers for sequential and parallel computer systems, a debugger (extensions to gdb and xgdb), and a large selection of sample algorithms from different areas, especially image processing. The sequential version of Parallax is available as a binary for Sun SunOS and Solaris, DEC Ultrix, HP 9000, IBM RS6000, SGI Irix, and Linux Intel platforms. There are parallel versions for MasPar MP-1 and MP-2, PVM clusters, and the Intel Paragon. The documentation is contained within a user's manual and a language definition report, both of which are available in PostScript format. See Braunl (1993).

[http://www.informatik.uni-stuttgart.de/ipvr/bv/p3/p3.html]

 

Parallel Processing Using Linux

A repository of practical information for those engaging in the sorcery of attempting parallel processing on Linux platforms. The plan is to have the usual stuff about parallel processing, e.g. software, hardware, documentation, etc., but to specialize in discussing complete parallel environments which integrate hardware configuration, parallel OS functions, libraries, languages, parallel I/O, and applications, i.e. the works. It is also planned to keep a list of open problems that have been identified in order that they can be tackled by many folks in the community. [http://yara.ecn.purdue.edu/~pplinux/]

 

parallel processing

The use of several machines or processors to perform computational tasks. The January 1988 issue of the Linux Journal contains many articles on parallel processing with Linux.

Parallel processing languages, environments, tools, etc. include aCe, ACE, Amoeba, A++/P++, ARCH, BETA, BLACS, BlockSolve, BSPlib, Calypso, C4, Cilk, Clean, Condor, Converse, COSMICS, Counterpoint, C*, CuPit, DAGH, DGENESIS, DIPC, dmake, Dome, DOUG, DSC, fsolver, GALOPPS, Global Array, GLU, JAVAB, JavaPVM, JAVAR, KeLP, LAM, LASSAP, Limes, LPARX, Maisie, mEDA-2, Mentat, Modula-2*, Moldy, MOM, mpC, MPI, MPICH, MPI-Cubix, MPI++, MPI-RGL, MSG, NAMD, Nascent, NESL, Nexus, Omega Project, OMIS, OOMPI, Orca, PACT, PADE, PAMELA, PANDA, PAPERS, Parallaxis, Parallel Toolbox, PARASOL, ParMETIS, ParPre, PBLAS, PCCM, PCG, PeIGS, PETSc, p4, PFSLib, PGAPack, PICL, Pike, PIM, PIOUS, PLAPACK, pPCx, PPI++, ppmake, PRM, Proteus, P-SPARSLIB, PSTSWM, PVM, pWEB, Quarks, QCDMPI, Reactive-C, RT++. sB-BLAS, ScaLAPACK, Sciddle, SHORE, Sisal, SYISDA, tclpvm, Tkpvm, TOOPS, TRAPPER, UfMulti, VIC, VPE, Xi, and youtoo.

 

Parallel Toolbox

A Matlab toolbox for running and testing parallel algorithms. [http://www.mthcsc.wfu.edu/pt/pt.html]

 

Paranoia

A program that strenuously tests a programming language implementation's floating point capabilities. Separate source code versions of this are available for C, Fortran (single and double precision versions), Basic, Modula-2, and Pascal. [http://www.netlib.org/paranoia/]

 

Para++

A set of C++ classes that allow message passing programs to be written by encapsulating message passing primitives into a higher level of abstraction. All communications are defined by using C++ streams. These C++ bindings have been implemented on top of both PVM and MPI. [http://www.loria.fr/para++/parapp.html]

 

PARASOL

A project to develop new parallel algorithms for the direct solution of sparse systems on linear equations and for the iterative solution of such systems based on either multigrid or domain decomposition, with any algorithms developed to be made available in the public domain. The objectives of the project are to develop sparse matrix algorithms according to the needs of industry, to implement portable prototypes of these solvers and to demonstrate them on different HPC systems, to specify an open library interface for the library, to integrate the solvers and additional utilities into the PARASOL library and provide an interface to the programming environment TRAPPER, to establish continuous library support, and to evaluate the library. [http://www.genias.de/parasol/]

 

PARI-GP

A package capable of doing formal computations on recursive types at high speed. It is primarily aimed at number theorists, but can be used by people whose primary need is speed. Symbolic manipulation a la Mathematica et al. is possible, but it usually fares poorly compared to the beforementioned systems. Its main advantages are speed (for certain classes of applications) and the possibility of directly using data types familiar to mathematicians. PARI can be used either as a library called from any upper-level language application (e.g. C, C++, Pascal and Fortran) or as a sophisticated programmable calculator (named GP). Binaries are available for Amiga, Mac, and MS-DOS systems as well as for several UNIX flavors (e.g. Dec Alpha, HP, Sun SPARC and Solaris, and Linux). The source code is also available. It comes with a 150+ page manual. There is an article about this package in the May 1995 issue of the Linux Journal. A related project is a PARI interface to the Python language called PariPython . [ftp://megrez.ceremab.u-bordeaux.fr/pub/pari]  

ParMETIS

A parallel multilevel graph partitioning and sparse matrix ordering library which implements a variety of algorithms for partitioning unstructured graphs and for computing fill-reducing orderings for sparse matrices. ParMETIS is useful for parallel numerical simulations involving large unstructured meshes, e.g. finite element simulations, wherein it can greatly reduce the time spent in communications by decomposing the mesh in a way that balances the load and minimizes the number of interface elements. The ParMETIS algorithms are based on those in the serial package METIS, and extend the functionality of the latter by including routines especially suited for parallel computations and large-scale numerical simulations. ParMETIS supplies four major functions: partitioning an unstructured graph, improving the quality of an existing partition, repartitioning a graph which corresponds to an adaptively refined mesh, and computing a fill-reducing ordering for sparse direct factorization. The algorithms are based on the parallel multilevel k-way graph partitioning scheme. The features of ParMETIS include: quick computation of high quality partitions of very large graphs, the use of geometry information to speed up the run time of partitioning algorithms without a loss in quality, the improvement of partitions produced by other algorithms, the quick computation of high quality repartitions of adaptively refined meshes wherein both the number of vertices that are moved and the edge-cut of the resulting partition are optimizes, the computation of low fill orderings for sparse direct factorization using a node-based nested dissection algorithm, the efficient use of memory for partitioning even very large graphs, and more.

A source code distribution of ParMETIS is available. It is written entirely in ANSI C and MPI and is portable to all platforms which support the latter. A user's manual is available in PostScript format as are several technical reports describing the algorithms used. See also METIS.

[http://www.cs.umn.edu/~karypis/metis/]

 

PARPACK

See ARPACK.

 

ParPre

A library of parallel preconditioners for iterative solution methods for linear systems of equations. The methods currently (3/97) available include additive and multiplicative Schwarz preconditioners and generalizd block SSOR. It currently has a C interface with a Fortran interface planned. ParPre runs over the MPI message passing library, and has been tested on the MPICH implementation. It also uses routines from the PETSc library, although they are included in the ParPre distribution. This is a component of the ScaLAPACK . [http://www.math.ucla.edu/~eijkhout/parpre.html]  

PARSEC

The PARallel Simulation Environment for Complex systems is a C-based discrete-event simulation language that adopts the process interaction approach to discrete-event simulation. In PARSEC an object (i.e. physical process) or set of objects in the physical system is represented by a logical process, with interactions among these processes (i.e. events) modeled by timestamped message exchanges among the corresponding logical processes. A distinguishing feature is the capability of executing a discrete-event simulation model using several different asynchronous parallel simulation protocols on a variety of parallel architectures. It is designed to cleanly separate the description of a simulation model from the underlying simulation protocol used to execute it. This allows a PARSEC program to be executed using the traditional sequential simulation protocol or one of many parallel optimistic or conservative protocols. There are also powerful message receiving constructs that result in shorter and more natural simulation programs as well as useful debugging facilities. PARSEC is derived from Maisie, and existing programs for the latter can be converted to the former. A source code distribution of PARSEC is available. It is written in C and runs on several platforms including Sun Solaris and Linux Intel. A user's manual is available in PostScript and PDF formats.

[http://may.cs.ucla.edu/projects/parsec/]

 

parser generator

A program that converts a grammar description in some type of context-free grammar into a program in some target language to parse that grammar. This are also known as compiler compilers, since they do indeed compile compilers. Available parser generators include Bison, byacc, LLgen, PRECCX, and RDP. See also the compiler construction tools, various package which contain parser generators as part of a suite of tools.

 

Particle Simulation Methods

A page summarizing the various methods used to simulate large systems of particles, e.g. in astronomy. This also has many links to available software in each category. [http://www.amara.com/papers/nbody.html]

 

Pascal

An evolutionary successor to Algol developed in 1970 by Niklaus Wirth at ETH Zürich. It cleaned up and left out some of the more obscure features of Algol and added the capability to define new data types out of existing ones. Pascal also supported dynamic data structures. This is one of the older languages still hanging around that has been used for numerical analysis over the years. A compiler called gps (Gnu Pascal) is available as is a site specializing in numerical analysis code for Pascal . There is also a Pascal to C translator called p2c. See Jensen and Wirth (1974) and Mallozzi (1989).  

PASSCAL

The Program for the Array Seismic Studies of the Continental Lithosphere at Lamont-Doherty provides a software package to aid in the field processing of seismic data collected from RefTek data recorders. The PASSCAL software suite consists of a set of utility programs for handling various tasks. These programs can be divided into several categories. The RefTek data processing programs are:

• ref2segy, which converts data from RefTek to a modified version of the SEGY format;
• ref2mseed, similar to ref2segy but also converts any compressed data streams into miniseed files;
• ref2log, same as ref2segy but it only writes a log file;
• ref2tab, which produces just database tables and logfiles from the RefTek data;
• tkref, a Tcl/TK GUI to program or interrogate the RefTek DAS;
• refpacket, which prints all packet headers from raw PASSCAL data;
• refcatalog, a diagnostic tool to produce an index of packets on a RefTek disk;
• refextract and tkextract, command line and GUI interfaces to extract specific events from a RefTek data stream;
• refgrep, for extractio of specific types of RefTek packets based on packet type and DAS number;
• diskclear, which clears the data from a SCSI disk written by RefTek;
• refecho, which echos to standard output the RefTek disk label;
• refdump, which copies from a SCSI disk the data written by a PASSCAL instrument;
• refserial, which reads raw RefTek data from a serial line;
• refpdata, which converts a RefTek data stream into a PASSCAL pdata stream;
• firfilt, which filters and decimates a trace;
• refclean, which removes and re-syncs erroneous packets from a data stream;
• disk2dat, a GUI allowing the writing of multiple reftek images to a single tape;
• refrate, a program for calculating clock offset and drift information from logfiles;
• clockcor, which determines the clock correction for a given SEGY file; and
• rateclean, which reads output from refrate and fixes erroneous one second correlations.

Display software programs are:

• pql, which provides a quick way to view SEGY, SAC, mini-SEED or AH seismic data in an X11 environment;
• psql, which provides summary PostScript output of SEGY or SAC traces;
• clockview, which provides X11 display of external clock phase errors;
• logview, a GUI providing useful graphs of information in logfiles;
• pmon, which takes a PASSCAL data stream as input and displays up to six channels in near real-time on X11; and
• tkdf, a script to create a bar graph display of the output from the UNIX df command.

Event association programs are:

• reap, which associates trace files with events; and
• creat_table, which reads the logfiles produce by ref2segy and creates a table with information about each trace file.

Miscellaneous programs include:

• human2epoch and epoch2human, which take a RefTek time string and returns the epoch seconds from Jan. 1, 1970 at 00:00 and vice-versa;
• hexdump, which prints a hexadecimal listing of a file;
• calday, which converts from Julian to calendar days;
• julday, which converts from calendar to Julian days;
• coherence, a suite of spectral analysis programs; and
• position, which calculates 2-D locations using GPS position statements.

Several other programs are also available for dealing with SEGY and mini-SEED data.

A source code distribution of the PASSCAL software suite is available. It has been successfully installed on Linux Intel platforms and requires the Tcl/Tk package. Each program is documented in a separate man page.

[http://www.ldeo.columbia.edu/Passcal/]

 

Pathetic Writer

An X Window-based word processor for Linux which uses Scheme as an extension language. See also the same author's SIAG and Egon Animator packages. [http://www.edu.stockholm.se/pw/]

 

PBLAS

The Parallel Basic Linear Algebra Subroutines are parallel versions of the BLAS subroutines for performing basic linear algebra computations. PBLAS is used as the underlying computational layer for the ScaLAPACK subroutine library. [http://www.netlib.org/scalapack/html/pblas_qref.html]

 

PBM

See Pbmplus.

 

Pbmplus

A toolkit for converting various image formats to and from portable formats and therefore to and from each other. This cuts down on the number of conversion filters needed. PBMPLUS also includes some simple tools for manipulating the portable image formats. The package is broken into four parts: PBM (Portable BitMap), the lowest common denominator (LCD) format for bitmaps; PGM (Portable GreyMap), the LCD format for grayscale images; PPM (Portable PixelMap), the LCD format for full color images; and PNM (Portable aNyMap), which is not a format itself but rather performs content-independent manipulations on any of the first three formats as well as handling external formats which have multiple types. The four parts are upward compatible in the obvious ways. The image types which can be converted to PBM are: Andrew Toolkit raster objects, Xerox doodle brushes, CMU window manager format, Group 3 FAX, Sun icon, GEM img, MacPaint, MGR, Atari Degas pi3, X10 or X11 bitmap (XBM), and Bennet Yee face files. Those which PBM can be converted to are: Gemini 10x, ASCII graphic, Andrew Toolkit raster object, BBN BitGraph, CMU window manager, Epson printer, Group 3 FAX, GEM img, GraphOn, Sun icon, HP LaserJet, MacPaint, MGR, Atari Degas pi3, UNIX plot(5), Printronix, X10 and X11 bitmaps (XBM), Bennett Yee face files, and Zin Interface Library icon. The image types which can be converted to PGM are: FITS, Usenix FaceSaver, HIPS, Lisp Machine bitmap, PostScript image data, and raw grayscale bytes. Those which PGM can be converted to are: FITS, Usenix FaceSaver, Lisp Machine format, and portable bitmap. The image types which can be converted to PPM are: GIF, Gould scanner file, IFF ILBM, Img-whatnot, MTV ray tracer, PC Paintbrush, Atari Degas pi1, Macintosh PICT, HP PaintJet, QRT, raw RGB bytes, AutoCAD slide, Atari compressed and uncompressed Spectrum, TrueVision Targa, Xim, XPM, and Abekas YUV. Those which PPM can be converted to are: AutoCAD database, GIF, NCSA ICR, IFF ILBM, PC Paintbrush, portable graymap, Atari Degas pi1, Macintosh PICT, HP PaintJet, X11 puzzle, DEC sixel, TrueVision Targa, Motif UIL, XPM, and Abekas YUV. Those which can be converted to PNM are: anything (attempted), Sun raster, TIFF, and X10 or X11 window dumps. The which PPM can be converted to are: PostScript, Sun raster, TIFF, and X11 window dump.

The functions which the many utility routine perform include: ordered dithering for color images; fractal forgeries of clouds, planets, and starry skies; printing histograms; quantizing colors; running a Laplacian Relief filter; Bentleyizing a portable graymap; edge-detecting or edge-enhancing a portable graymap; normalizing contrast in a portable graymap; performing arithmetic on two portable anymaps; concatenating anymaps; rotating, scaling, shearing, inverting, enlarging, and describing anymaps; and many more.

The source code for the package is available. It is written in C and can be compiled using either a Makefile or an Imakefile supplied in the distribution. ELF binary versions of the package are available at the Linux repositories. Each tool in the package is documented in a separate man page. A newer version of this with some additional capabilities is Netpbm.

[ftp://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/graphics/convert/ ]
[http://www.acme.com/ ]

 

PCCM

A Parallel version of the NCAR Community Climate Model implemented for MIMD massively parallel computers using a message passing programming paradigm. The CCM is a package including an atmospheric general circulation model (AGCM), a slab ocean model, and a surface processes model to simulate the climate of the Earth given the appropriate boundary conditions. The parallelization strategy decomposes the problem domain into geographical patches with each processor assigned a subset of the collection of patches. The physics calculations involve only grid points and data local to a processor and are performed in parallel. The dynamics are also computed in parallel using special algorithms developed for semi-Lagrangian transport, the FFT, and the Legendre transform. The PCCM was developed for the Intel Paragon and the IBM SP2 but will also run on a network of workstations running the PVM package. The source code for PCCM is available. It is written in Fortran 77 and documented in a user's guide available in PostScript format.

[http://www.epm.ornl.gov/chammp/pccm2.1/index.html]

 

PCCTS

The Purdue Compiler Construction Tool Set has been renamed ANTLR.  

PCG

The Preconditioned Conjugate Gradient package is a system for solving linear equations which employs various gradient-type iterative methods coupled with preconditioners of various types. It is designed to be applicable to general linear systems with special emphasis given to sparse systems which might arise from the discretization of PDEs arising from physical applications. It is also designed to give high performance with a nearly identical user interface across different programming models such as shared memory, data parallel, and message passing programming interfaces. The features of PCG include: the availability of a wide variety of iterative methods, e.g. the conjugate gradient (CG) and conjugate gradient squared (CGS) methods, the biconjugate gradient (BCG) and QMR algorithms, and restarted GMRES; the availability of a wide variety of preconditioners including variants of point and block Jacobi; predefined matrix storage schemes chosen to provide sufficient generality to implement a wide variety of sparse problems as well as to take advantage of the various machine architectures; a choice of several levels of access, e.g. a top level or black box call using a predefined sparse matrix format, an iterative method level with a direct communication interface, etc.; several matrix preprocessing options to improve the solution process; all package routines available in single and double precision as well as real and complex versions (which follow the LAPACK naming conventions); a high degree of modularity wherein any combination of preconditioner, iterative method, matrix format, arithmetic, precision and machine type can be used to solve a problem; optimization for high performance on particular parallel machines; portability across several parallel and scalar platforms; and more.

Several versions of the PCG package are supposed to eventually be available. Currently (3/97) the FTP site contains uniprocessor Fortran 77 and Cray YMP versions of the source code. I compiled the uniprocessor version successfully with g77 0.5.19.1 with no code modifications being necessary. The documentation, available separately, includes a reference manual, an examples manual, a tutorial for beginners, and some technical reports, all in PostScript format. See Jourbert (1994).

[http://www.cfdlab.ae.utexas.edu/pcg/]
[http://www.netlib.org/linalg/ ]

 

PCHIP

A collection of Fortran 77 routines for the piecewise cubic Hermite interpolation of data. It features routines to produce a monotone and visually pleasing interpolant to monotone data. Routines to determine derivative values include: PCHIM, used if the data are monotonic or if it is desired that the interpolant stays within the limits of the data; PCHIC, used if neither of the above conditions hold or if control over boundary derivatives is desired; and PCHSP, which produces a cubic spline interpolator in cubic Hermite form for comparison purposes. The routines used to evaluate, differentiate, or integrate the resulting functions include: CHFEV, to evaluate a single cubic Hermite function at an array of points; PCHFE, used when the interval is unknown or if the evaluation array spans more than one data interval; CHFDV, which evaluates a single function and its first derivative at an array of points; PCHFD, used when the interval is unknown or the evaluation array spans more than one data interval; PCHID, computes the definite integral of a function when the integration limits are data points; and PCHIA, computes the integral over an arbitrary finite interval. The routine PCHMC is a monotonicity checker and CHFIV, CHFMC, PCHCE, PCHCI, PCHCS, PCHDF, PCHST, and PCHSW are internal routines to perform various tasks. A source code distribution of the PCHIP package is available. All the routines are written in Fortran 77 and are documented via comment statements included in each source code file. This is part of CMLIB. See Fritsch and Carlson (1980) and Fritsch and Butland (1984).

[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]

 

PCMCIA

The Personal Computer Memory Card International Association is an international standards body and trade association founded in 1989 to establish standards for integrated circuit cards and to promote interchangeability amongst all platforms. The PC Card Standard defines a 68-pin interface between the peripheral card and the socket into which it is inserted. It also defines a software architecture to provide ``plug and play'' capability across a wide range of products, with the software comprised of Socket Services and Card Services. A complete PCMCIA support package for Linux platforms is Card Services. [http://www.pc-card.com/]

 

PCNFSD

A PC NFS authentication and print request server which supports ONC clients on DOS, OS/2, Macintosh and other systems. The printing model supported is based on the use of NFS to transfer the actual print data from the client to the server. When the server receives an authenticatin request, it will log in the user by validating the user name and password and returning the corresponding uid, gids, home directory, and umask. It will also add any entry to the wtmp data base if so desired. A source code version of this is available which has a makefile modified for compilation on Linux systems. It is documented in a man page. This can be obtained as part of the Shadow Ina Box tool suite. [http://sunsite.unc.edu/pub/Linux/system/admin/]

 

PCthreads

A multithreading library for Linux-based Intel systems which is based on the POSIX 1003.1 standard for threads. It contains the sources for the library (libpthreads), a build environment for both ELF and a.out binaries, and a complete set of man pages for all POSIX.1c functions. In addition to the multithreading API, the package provides: structured exception handling with TRY-CATCH-ENDTRY, sources to a non-blocking version of the BSD socket library, non-blocking select() and non-blocking read() and write(), a large amount of example code, and several runtime configurable parameters including clock interrupt interval, default thread scheduling policy, default thread stack size, and the I/O polling interval. [http://www.aa.net/~mtp/PCthreads.html]

 

PCx

An interior-point predictor-corrector linear programming package for solving optimization problems. The features include: a set of high-level data structures for linear programming constructs designed for possible reuse in other codes; the ability to be invoked both as a stand-alone program and as a callable procedure; a presolver; and a modular structure which makes it easy for users to modify the code to experiment with variants of the current algorithm. PCx accepts any valid linear program that can be specified in the MPS format. The source code is available as are binaries for Sun SunOS and Solaris, IBM AIX, SGI IRIX, HPUX, Intel Linux, and DEC Alpha platforms. The source code is written in both C and Fortran and thus requires compilers for each. The documentation is contained within a user's guide in PostScript format that is included in the distribution.

[http://www.mcs.anl.gov/home/otc/Library/PCx/]

 

PDECOL

See PDELIB.

 

PDELIB

A collection of Fortran routines which solve general systems of nonlinear, initial and boundary value partial differential equations (PDEs) in one or two space dimensions, with each routine based on the method of lines. The components of the package are MOL1D, PDECOL, and PDETWO. MOL1D solves systems of linear or nonlinear initial and boundary value problems in one space dimension. It can solve hyperbolic problems with or without dicontinuities and parabolic equations (including reaction-diffusion equations). It uses the method of lines based on equi-spaced finite differences. PDECOL solves general systems of initial and boundary value problems in one space dimension with general boundary conditions, with spatial derivatives allowed to be at most second order. This uses the method of lines based on the collocation of B-spline basis functions. PDETWO solves general nonlinear systems of initial and boundary value problems in two spatial dimensions with quasi-linear boundary conditions. It uses the mthod of lines based upon finite differences on a user-specified rectangular mesh.

All of the components of PDELIB are written in Fortran and available as source code. Each component is documented in a separate ASCII file which servers as a user's manual. See Madsen and Sincovec (1979).

[http://math.nist.gov/cgi-bin/gams-serve/list-package-components/PDELIB.html]

 

PDETWO

See PDELIB.

 

PDF

The Portable Document Format is the underlying file format for the Acrobat family of document interchange products created by Adobe (who also created the earlier PostScript format). Any document that would normally be printed can now instead be turned into PDF which represents the exact appearance of the printed document, which can then be viewed with an Acrobat Reader. In addition to representing the printed pages of a document, Acrobat supports additional navigational aids such as hyperlinks, bookmarks, and thumbnail views of images. The Acrobat Reader is freely available for most platforms, but to create PDF documents you need the commercially available Adobe PDFWriter or Distiller products.

PDF is based on Level 2 PostScript although it uses a simplified and limited set of operators, and no new operators can be defined and there are no interative constructs. A file is structured as a number of separate objects, each of which are numbered, which may refer to each other and appear anywhere in the file. PDF files cannot as yet (3/97) be sent directly to printers to obtain hardcopy. They must first be run through a filter to convert them to PostScript and then printed. This conversion can be accomplished on Linux platforms using either the Acrobat Viewer or the xpdf package. Informative sites include the PDF Corner , the PDF Zone , and the Adobe Acrobat site mentioned above.  

pdftex

A program to translate TeX source code files into PDF files. [http://tug2.cs.umb.edu/ctan/tex-archive/systems/pdftex/index.html]  

pdksh

A UNIX shell which is a mostly complete AT&T ksh (Korn Shell) lookalike. It is still under development to make it compatible with both POSIX and ksh whenever possible. The ksh was designed to be a compatible extension of the Bourne shell which added features from the csh and some new ones of its own. The new features included: interactive editing of the command line including file name completion and the ability to edit the history list; improved function definitions providing local variables and the ability to write recursive functions; extended pattern matching for file names and other constructs (i.e. a feature similar to regular expressions); the ability to extract the portion of a string specified by a pattern; and the ability to switch easily between two directories. The ksh should run almost any Bourne shell script and is a superset of the POSIX shell sh (with the ksh having served as the primary model for formulating sh). See Abrahams and Larson (1996), Bolsky and Korn (1995), Olczack (1992), and Rosenblatt (1993). [http://sunsite.unc.edu/pub/Linux/system/shells/]
[ftp://ftp.cs.mun.ca/pub/pdksh/ ]

 

PDP++

A neural network simulation system written in C++. The features include: a full GUI based on the InterViews toolkit; a network viewer that shows network architecture and processing in real time and allows networks to be constructed via point-and-click actions; online graphing of training and testing data; online display of the network state either numerically or graphically; an environment viewer that shows training patterns using color or size-based graphical representations; a flexible object-oriented design which allows full mix-and-match simulation construction and easy extension by deriving new object types from existing ones; a built-in scripting language (CSS) which uses C++ syntax and allows full access to simulation object data and functions (and includes command-line completion, a source-level debugger, and standard C/C++ library functions; script control of processing, generation of training and testing patterns, routine task automation, etc.; generation of scripts from GUI actions; the creation of GUI interfaces from script objects to extend and customize the simulation environment; and more. The algorithms supported by PDP++ include: feedforward and recurrent error backpropagation with recurrent BP including continuous, real-time, and Almeida-Pineda models; constraint satisfaction algorithms and associated learning algorithms including Boltzmann macnine, Hopfield models, mean-field networks (DBM), Interactive Activation and Competition (IAC), and continuous stochastic networks; self-organized learning including competitive learning, soft competitive learning, simple Hebbian, and self-organizing maps (i.e. Kohonen nets); and mixtures-of-experts using backpropagation experts, EM updating, and a SoftMax gating module.

PDP++ is written in C++ and is available as source code. Both the Cfront 3.x and g++ 2.7.2 compilers are supported. Binaries are also available for Sun, SGI, HP, Linux Intel and IBM AIX platforms. A 250+ page user's manual is available in PostScript format.

[http://www.cnbc.cmu.edu/PDP++/]

 

PEAKFQ

A program for computing flood frequency analyses based on the guidelines in Bulletin 17B published by the Interagency Advisory Committee on Water Data in 1982. PEAKFQ uses the method of moments to fit the Pearson Type III distribution to the logarithms of annual flood peaks. The skew used may be a generalized skew for a region, from the Bulletin 17B skew map, computed from the data, or weighted between the generalized and station skews. Adjustments can be made for high and low outliers and historic information, and qualification codes may be used to censor data from the analysis. A source code distribution of PEAKFQ for UNIX platforms is available. The primary documentation is contained within Kirby (1981). This is part of the USGS Water Resources Applications Software collection.

[http://water.usgs.gov/software/peakfq.html]
[http://www.geogr.uni-jena.de/software/peakfq.html ]

 

PEARL

The Process and Experiment Automatization Realtime Language is a language for real time computations. A binary version of PEARL for Linux Intel platforms is available via this URL, although the documentation is written entirely in German. [http://www.stud.uni-hannover.de/~hemmerli/pearl.html]

 

PeIGS

A collection of commonly used linear algebra subroutines for computing the eigensystem of the real standard symmetric eigensystem problem Ax=$\lambda$x and the general symmetric eigensystem problem Ax=$\lambda$Hx where A and H are dense and real matrices with B positive definite and $\lambda$ is an eigenvalue corresponding to eigenvector x. PeIGS can, in addition to solving linear algebra problems of the above type, also handle associated computations such as the Cholesky factorization of positive definite matrices in packed storage format and linear matrix equations involving lower and upper triangular matrices in distributed packed row/column storages. Dense and real matrices are assumed throughout the computation, and only double precision is currently (4/97) supported. PeIGS is designed for parallel and distributed memory computers with a high startup time for communications, e.g. the Intel Paragon and the IBM SP-1. It can also be used on workstations linked together using message passing software such as TCGMSG and MPI. The installation procedures creates BLAS and LAPACK libraries which can be replaced with optimized version if so desired.

The PeIGS distribution contains the source code, written in Fortran and C, and can be installed on most generic UNIX systems with compilers for both. The package is documented in a 50+ page user's manual in PostScript format included with the distribution.

[ftp://ftp.pnl.gov/pub/permanent/emsl/]
[http://www.hensa.ac.uk/parallel/applications/numerical/
peigs/index.html ]

 

Penguin

A Perl 5 module that provides a set of functions that allow the sending of encrypted, digitally signed perl code to a remote machine to be executed and the receiving and execution of such code in an arbitrarily secure, limited compartment. The author describes it as ``Java done right.'' These functions enable the Perl coding of algorithms to handle safe internet commerce, mobile information-gathering agents, live content web browser helper applications, distributed load-balanced computation, remote software update, Internet-wide shared-date applications, and much more. [http://www.eden.com/~fsg/penguin.html]
[http://src.doc.ic.ac.uk/packages/perl/CPAN/modules/by-module/Penguin/ ]

Pentium Optimized BLAS

See under BLAS.

 

PEQMOD

The Primitive EQuation Model is a simple mechanistic 3-D primitive equation atmospheric circulation model which uses pressure coordinates. This model assumes that the planetary surface is essentially smooth and that there is sufficient drag acting near the lower boundary to make the details of the lower boundary conditions (which are very difficult to apply in pressure coordinates) unimportant. The pressure levels, level thicknesses, and zonal and meridional resolution are easily modified. Almost no physical parameterizations are included except for simple forms of scale selective damping and Newtonian/Rayleigh friction. The source code is written in Fortran 77 and a manual is included in TeX format. See Hoskins and Simmons (1975). [http://www.cgd.ucar.edu/gds/svn/]

 

PERHOM

A Fortran program for the PERiodic solution of nonlinear one-parameter-dependent ordinary differential equations using the HOMotopy method. PERHOM solves such two-point boundary value problems with period solutions of an unknown period length using a multiple shooting approach and a homotopy method. The source code distribution of this is documented via comment statements contained within the code itself. This is part of CodeLib. [ftp://elib.zib.de/pub/elib/codelib/perhom/]

 

PERIOD

A Starlink Project package designed to search for periodicities in data, i.e. perform time series analysis. PERIOD is a menu-driven package with several menu options. These options include: INPUT, to read an ASCII file; OGIP, to read OGIP FITS table data; FAKE, the create fake data using either a user-specified number of sine curves or a logistic equation for chaotic data; NOISE, to add noise to or randomize data; DETREND, to detrend data by removing DC bias which would cause significant power at 0 Hz; WINDOW, to set data points to unity to deal with the problem of spectral leakage; OPEN, to open a log file; CLOSE, to close a log file; PERIOD, to find periodicities using a sub-menu with choices for selecting data slots, set/show frequency search limits, calculate the chi-squared of sine fit versus frequency, obtain a CLEANed power spectrum or a discrete Fourier power spectrum, perform phase dispersion minimization, calculate a Lomb-Scargle normalized periodogram, get string-length versus frequency, calculate periods from the periodogram, enable/disable significance calculations, and get online help; FIT, to fold the data on a given period and zero point and fit it with a sine curve; FOLD, to fold the data on a given period and zero point to transform it onto a phase scale; SINE, to add, subtract, multiply, or divide a sine curve from data; PLT, which calls PGPLOT to display a graph; STATUS, which returns information on the data slots or the stored fits in the log file; OUTPUT, which writes to an ASCII file; and HELP, for online help. A binary distribution of PERIOD is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. The program is documented in a 15 page user's manual available in PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

PERIOD (ODE)

A Fortran program for the solution of nonlinear two-point boundary value problems with periodic solutions of an unknown period length. PERIOD uses a multiple shooting method approach to find a solution. The source code distribution of this is documented via comments within the code itself. This is part of CodeLib. [ftp://elib.zib.de/pub/elib/codelib/period/]

 

Perl

An interpreted scripting language optimized for scanning arbitrary text files, extracting information therein, and printing reports based on that information. It's also a good language for many system administration tasks. This is probably the most widely used and important scripting language. I've noticed that it's a love/hate sort of thing with Perl as epitomized by its creator, Larry Wall, expanding the acronym PERL as both Practical Extraction and Report Language and Pathetically Eclectic Rubbish Lister. But if you're going to perform net-related adminstration or other tasks, you probably need to be somewhat familiar with it. The given URL is to the Perl Language Home Page. You might also want to check out the Perl Institute site, which acts as a coordinating and communication center to connect people, information, ideas and resources. There is a page with information about Perl 5 with tips on what's necessary to migrate from earlier version to Perl 5. There is also the Perl Module Map , a guide to Perl modules that can be used to include additional functionality in basic Perl via a standard interface. And then there is the inevitable Perl FAQ . See Deep (1996), Dichter and Pease (1995), Schwartz (1993), Schwartz (1997), Vromans (1996), Wall and Schwartz (1991), Wall et al. (1996), and Wong (1997). Software packages written using Perl, which modify or extend Perl, or which require Perl for use or installation include: Apache, Automake, Basis, btng, CGIperl, CHARM, Checkbot, C*, dbedit, Elex, ePerl, EPIC, FastCGI, FIDOGATE, FLpr, FOAM, FTE, FTOOLS, GAGS, gd, Gifmap, GlimpseGate, Gre, gtml, Guile, gwstat, htgrep, htmlpp, html2ps, HyperNews, Jrju, keeper, latexmk, LaTeX2HTML, lbnamed, Perl, libwww-perl, LONI, Ltoh, MacroCALC, Majordomo, MHonArc, mod-perl, MPP, mSQL, MTX, mysql, NAGS, NetCDFPerl, NetForum, Nexus, Perl, Oorange, Penguin, PerlDL, PerlMagick, Perl-PVM, perlSGML, perlTk, PGPERL, pod2ps, premail, pscover, RANDLIB, RIB, RNPL, SDF, sdoc, SPONG, Stow, SWIG, texi2html, troff2html, UCM, udunits, Wafe, WebGlimpse, WebMagick, Webmin, WebOOGL, WML, WODA, wwwtable, wwwstat, Xforms4Perl, Xitami, Yard, and Zlib. [http://www.perl.com/perl/index.html]

 

PerlIDL

Perl Data Language is an extension that gives Perl the ability to compactly store and speedily manipulate the large N-dimensional data arrays that are the hallmark of scientific computing. The goal of this package is to turn Perl into a free, array-oriented numerical language similar to commercial packages like IDL and Matlab where simple expressions can be written to manipulate numerical arrays. The first official release (10/96) provides the fundamental numerical processing facilities and a limited set of standard functions. Graphics are supported via the Perl PGPLOT module and image display via the external programs SAOImage and XIMTool, with I/O currently supported via the FITS standard.

[http://www.aao.gov.au/local/www/kgb/perldl/]

 

PerlMagic

An objected-oriented Perl interface to ImageMagick. This is a Perl module that can be used to read, manipulate, or write an image or image sequence from within a Perl script, which makes it very suitable for Web CGI scripts. There are routines for setting image attributes, manipulating images, getting image attributes, creating an image montage, and performing miscellaneous other tasks. The source code for PerlMagic is available and requires ImageMagick 3.8.2 or greater and Perl version 5.002 or greater. The code and its documentation are currently (3/97) is the alpha stage.

[http://www.wizards.dupont.com/cristy/www/perl.html]

 

Perl-PVM

A Perl extension for the PVM message passing system. This allows the development of applications for real-time and client/server systems. [http://phobos.nsrc.nus.sg/STAFF/edward/Pvm.html]

 

perlSGML

A collection of Perl programs and libraries for processing SGML documents. The program collection includes:

• dtd, a library which parses an SGML document type definition (DTD) and creates Perl data structures containing the content of the DTD;
• dtd2html, a program which generates an HTML document which itself documents an SGML DTD and allows the hypertext navigation of an SGML DTD;
• dtddiff, which lists the changes that have occurred in a DTD, e.g. new elements and attributes, old/removed elements and attributes, and content rule changes;
• dtdtree, which outputs the content hierarchy tree of the SGML elements defined in a DTD;
• dtdview, an interactive SGML DTD querying tool which provides a command-line interface to access element content rules, element attributes, and the structure of a DTD;
• sgml, a library which parses an SGML document instance; and
• stripsgml, which removes SGML markup tags from a file and also attempts to translate standard character entity references to ASCII.

The perlSGML distribution is available as standalone programs written in Perl 4 or as Perl 5 modules. Each program is documented in an extensive man page.

[http://www.oac.uci.edu/indiv/ehood/perlSGML.html]

 

perlTk

A Perl module that weds the Tcl/Tk widget set to Perl 5, i.e. an interpreted scripting language for making widgets and programs with graphical user interfaces. The perl/Tk code is a rewrite of the Tk code that allows easier external linking and calling, especially by Perl. It is planned to eventually be a "portable Tk" package which will be a library usable from Tcl, LISP, C++, python, and other languages besides Perl. [http://w4.lns.cornell.edu/~pvhp/ptk/ptkFAQ.html]

 

PerlTools

A package which makes using regular expressions in Java as easy as in Perl. It provides Perl 5 regular expressions support for Java programs by allowing regular expressions to be specified exactly as they would be in Perl. It also takes care of compiling and caching the expressions and performs the matching, splitting or substitution operations. A source code implementation of NetComponents is freely available under the terms of a non-exclusive, non-transferable limited license whose details are available at the site. This uses the related OROMatcher and TextTools packages which are included in the distribution. The API is documented in HTML format.

[http://www.oroinc.com/]

 

Perl modules

A Perl package provides a mechanism for alternative namespaces to protect packages from interfering with each other's variables. A Perl module is a reusable package that is defined in a library file whose name is the same as the name of the package. Thus this provides a standard mechanism for extending Perl via external programs. There are literally hundreds of Perl modules available via CPAN and elsewhere. A CPAN bundle is a collection of modules that comprise a cohesive unit.

Some useful Perl modules include: Embperl and Penguin.

 

Petidomo

A mailing list processor and manager. The features of Petidomo include:

• configuration and maintenance of mailing lists via a web browser;
• setting administrator passwords separately for each mailing list;
• a powerful access control language for configuring who is allowed to do what, e.g. keeping spam out of lists, limiting the number of people who can post, etc.;
• an archive of posted articles that can be made available via the Web, a news server, or FTP;
• automatic recognition and redirection of commands meant for the list server which are posted on the mailing list, i.e. no more plagues of ``unsubscribe me'' posts;
• a sophisticated mail rescue mechanism which stores a post in a directory for manual intervention whenever posting or processing fails due to a bug, faulty mail headers, or misconfiguration;
• virtual hosting, i.e. one server can host an arbitrary number of mailing lists with each running under a separate domain name;
• runs with all known mail transport agents;
• operation of public forums, closed mailing lists, moderated lists or secret mailing lists; and
• support for fully encrypted mailing lists using PGP.

A source code distribution of Petidomo 1.3 is freely available for non-commercial use, scientific or educational purposes. It is written in C and can be compiled on most UNIX platforms. Version 2.0 is a commercial product. It is documented in a user's manual available in HTML and PostScript format.

[http://www.w3.org/pub/WWW/Daemon/]

 

PETSc

The Portable Extension Tools for Scientific computing is a large suite of data structures and routines for both uni- and parallel-processor scientific computing. It is intended especially for the numerical solution of large-scale problems modeled by partial differential equations, and provides a rich environment for modeling scientific applications as well as for rapid algorithm design and prototyping. The latest version (2.0) uses MPI for all interprocessor communication on parallel systems, although it can also run on single processor machines without MPI. PETSc consists of components that provide much of the functionality required for the parallel solution of PDEs. The components include:

• Vec, which provides the vector operations needed for setting up and solving large-scale linear and nonlinear problems, including parallel scatter and gather operations as well as special purpose code for handling ghost points for regular data structures;
• Mat, a large suite of data structures and code for the manipulation of parallel sparse matrices including four different parallel matrix data structures, each appropriate for a different class of problems;
• PC, a collection of sequential and parallel preconditioners;
• KSP, which contains parallel implementations of many popular Krylov subspace iterative methods, all coded to be immediately useful with any preconditioners and any matrix data structures;
• SNES containing data-structure-neutral implementations of Newton-like methods for nonlinear systems; and
• TS, containing code for the time evolution of PDE solutions and also provides pseudo-transient continuation techniques for computing steady-state solutions.

Additional features of PETSc include: parallel vectors; parallel scatters and gathers; parallel matrices including several sparse matrix storage formats; easy and efficient parallel matrix assembly; sequential sparse matrix direct solvers; scalable parallel preconditioners and Krylov subspace methods including ICC, ILU, block Jacobi, overlapping Schwarz, CG, GMRES, and Bi-CG-stab; scalable parallel nonlinear equation and unconstrained minimizationsolvers including line search and trust region Newton methods; simple parallel ODE solvers for applying the method of lines to large scale nonlinear time-dependent PDEs; distributed arrays; automatic profiling of floating point and memory usage; a consistent interface for all solvers and data structures; intensive error checking; and more.

A source code distribution of PETSc is available. It can be installed on a wide variety of UNIX flavors with or without MPICH, including Linux Intel. Extensive PostScript and on-line documentation is available. See Balay et al. (1997).

[http://www.mcs.anl.gov/petsc/petsc.html]

 

PEX

The PHIGS Extension to X is an extension to the core X protocol to provide 3-D grahpics support within the X Window environment. The acronym is currently more or less generic since versions 6.0 and later aren't specifically designed for PHIGS, but rather to support 3-D application programs in general. So in addition to PHIGS and PHIGS PLUS, PEX supports many other 3-D graphics APIs with display list mode, immediate mode, or a mixture of both. The standard X11 distribution includes code for the Sample Implementation (PEX-SI) of the extensions which implement the functionality defined by the PEX Protocol Extensions. Also included is PEXlib, the client side library or API for PEX. See Blake (1993), Gaskins (1992), Howard and et al. (1991), and Kasper and Arns (1992).

 

Pfau Zeh

An emulator for the Commodore VIC-20 computer which runs nearly all available VIC-20 software. It can be used to play games or to write programs in BASIC V2, and comes with a GUI. Versions exist for Win32 and Linux Intel. [http://stud.fbi.fh-darmstadt.de/~bockhold/pfauzeh.html]

 

PFE

The Portable Forth Environment is an interactive environment for the development of Forth programs. It is ANS compliant and written in ANSI C. [http://sunsite.unc.edu/pub/Linux/devel/lang/forth/]

 

pForth

An ANSI-style Forth designed to be portable across many platforms, with the ``p'' standing for ``portable.'' Versions are available for UNIX, PC and Mac platforms. A reference manual is available as well as a Forth tutorial. [http://www.softsynth.com/pforth/]

 

p4

A library of macros and subroutines developed at Argonne National Laboratory for programming a variety of parallel machines in C and Fortran. Its predecessor was the m4-based "Argonne macros" system described in the Holt, Rinehart, and Winston book "Portable Programs for Parallel Processors, by Lusk, Overbeek, et al., from which p4 takes its name. The current p4 system maintains the same basic computational models described there (monitors for the shared-memory model, message-passing for the distributed-memory model, and support for combining the two models) while significantly increasing ease and flexibility of use. The features of version 1.3 of p4 include: a library of useful monitors for shared-memory programming; portable monitor-building primitives; send/receive for shared-memory, distributed memory, and clusters; support for heterogeneous computing; an Emacs info version of the manual for on-line help; shared-memory programming even on uniprocessor workstations; instrumentation for automatic logging/tracing; either automatic or user-controlled buffer-pool management; remote startup, i.e. no daemons necessary; optional secure server for faster startup on networks; optional automatic logging of events for upshot tracing; asynchronous communication of large messages; global operations (broadcast, global sum, max, etc.); and both master-slave and SPMD models for message-passing programs.

The p4 system is intended to be portable, simple to install and use, and efficient. It can be used to program networks of workstations, distributed-memory parallel supercomputers like the Intel Paragon, the Thinking Machines CM-5, and the IBM SP-1, as well as shared-memory multiprocessors like the Kendall Square. It has currently been installed on the following list of machines: Sequent Symmetry (Dynix and PTX), Convex, Encore Multimax, Alliant FX/8, FX/800, and FX/2800, Cray X/MP, Sun (SunOS and Solaris), NeXT, DEC, Silicon Graphics, HP, and IBM RS6000 workstations, Stardent Titan, BBN GP-1000 and TC-2000, Kendall Square, nCube, Intel IPSC/860, Intel Touchstone Delta, Intel Paragon, Alliant Campus, Thinking Machines' CM-5, and the IBM SP-1 (TCP/Ethernet, TCP/switch, EUI, and EUI-H). It is not difficult to port to new systems. It is documented in a user's manual available in PostScript format.

[http://www.netlib.org/p4/]

 

PFSLib

A library that offers parallel access to files for a parallel application running on a cluster of workstations. PFSLib is a parallel file system library which provides source code compatibility with Intel's parallel file system PFS. It is primarily intended to work together with NXLib as an emulator of a Paragon supercomputer, but it can also be used as a standalone software product together with other parallel programming environemnts like PVM. and other software. PFSLib was tested and runs on several platforms, including Linux. This software will apparently be absorbed into a newer project called TOOL-SET for PVM , although it is still available as a standalone package. PFSLib is available as source code. The documentation is contained within some papers and technical reports available in PostScript format. [http://wwwbode.informatik.tu-muenchen.de/~lamberts/
PFSLib/]
[http://www.hensa.ac.uk/parallel/libraries/communication/
pfslib/ ]

 

PGA

A simple testbed for basic explorations of genetic algorithms. Parallel Genetic Algorithms allows multiple populations with periodic migration among them and a range of other options. PGA is written in C and can be compiled and used on most UNIX platforms. It is documented in a user's guide in LaTeX format. [http://www.aic.nrl.navy.mil/galist/src/]

 

PGAPack

A general-purpose parallel genetic algorithm library. The features include: programs callable from Fortran and C; runs on uniprocessors, parallel computers, and workstation networks; binary-, integer-, real-, and character-valued native data types; object-oriented data structure neutral design; parameterized population replacement; multiple choices for selection, crossover, and mutation operators; easy integration of hill-climbing heuristics; an easy-to-use interface; full extensibility; extensive debugging facilities; and a large set of example problems. The source code of PGAPack is available and can be installed and used on most generic UNIX systems. It is written in ANSI C and uses the MPI message passing interface for parallel and distributed computations. The supplied configuration file is set up for several platforms, including Linux. The package is documented in a user's guide available in PostScript format.

[ftp://info.mcs.anl.gov/pub/pgapack/]

 

PGCC

A suite of Pentium optimizations for the GCC compiler developed by the Pentium Compiler Group. The sources and patches are available as are compiler ports and binaries for Linux Intel, DOS DJGPP, FreeBSD, Solaris/X86, and BSDI platforms. [http://www.goof.com/pcg/]

 

PGM

See Pbmplus.

 

PGP

Pretty Good Privacy is a program that gives your electronic mail privacy. It can be used to encrypt a message or to apply a digital signature to a message without encrypting it, the latter bit allowing others to confirm if a message is really from you. It's supposedly illegal to obtain copies of PGP from the USA from sites outside the USA, so you've been fairly warned. The given URL is to the EFF PGP archive, which contains much more information about PGP, its use, the controversy surrounding its use and distribution, and how to obtain it. Linux users might find the PGP and Linux page interesting. See Garfinkel (1994), Zimmermann (1995), and Zimmermann (1995). [http://www.eff.org/pub/Net_info/Tools/Crypto/PGP/]
[ftp://ftp.ifi.uio.no/pub/pgp/ ]
[ftp://ftp.funet.fi/pub/crypt/cryptography/pgp/ ]
[http://thegate.gamers.org/~tony/pgp.html ]

  

pgperl

A Perl module which allows the PGPLOT graphics library to be used with the package with the Perl scripting language. It makes it easy to process and plot data using the powerful file and text manipulation facilities built into Perl. [http://www.ast.cam.ac.uk/AAO/local/www/kgb/pgperl]

  

PGPLOT

A Fortran callable, device-independent graphics library for making simple scientific graphs which is intended for making graphical images of publication quality with a minimum of effort on the part of the user. It consists of two major parts: a device-independent part written in Fortran 77 and a set of device-independent device handler subroutines for output on various terminals, image displays, and printers. PGPLOT device handlers are available for GIF, HP-GL, PPM,, PostScript and X Window dump formats; Tektronix and DEC Regis terminals; Canon, DEC LN03, Epson dot-matrix, HP Laseret, QUIC, and other printers; PGPLOT graphics metafile, TeX PK font output, and LaTeX picture environment formats; and much more. There are ports for several varieties of UNIX (e.g. Linux, SunOS, Solaris, HPUX, AIX), VMS, NeXTstep, DOS, Windows, Windows/NT, and Mac platforms. The documentation is contained within a user's manual available in PostScript format.

The basic PGPLOT package also supports a limited interactive capability on devices with a cursor for graphical input (e.g. X Windows workstations), although much greater interactivity is available via various front-ends that have been built by other users. These include PGPERL, STAP, ptcl, and WIP.

[http://astro.caltech.edu/~tjp/pgplot/]

 

PGXTAL

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

 

Phantom

An interpreted language designed to address some of the problems presented by large scale, interactive, distributed applications such as distributed conferencing systems, multi-player games, and collaborative work tools. It combines the distributed lexical scoping semantics of Obliq with a substantial language core based on an safe, extended subset of Modula-3. It supports a number of programming features including static structural-equivalence typing, objects, modules and interfaces, lightweight threads, exceptions, garbage collection, higher-order functions and lambda expressions, a keyword binding mechanism, dynamically sized lists, and type-safe implicit declarations. The source code for the interpreter, implemented entirely in ANSI-C, is available. It compiles programs to byte-codes for a virtual machine similar to that used in Scheme48. Phantom has goals similar to those that led to the development of Java, although there are a number of differences. It is known to compile and work on Linux and SunOS platforms. is presently in alpha release. The documentation includes a language overview, a language reference manual, and several technical papers, all avaiable in PostScript format.

[http://www.apocalypse.org/pub/u/antony/phantom/
phantom.html]

 

PHiPAC

The Portable High Performance ANSI C package can automatically generate fast BLAS-GEMM compatible matrix-matrix multiply code that reaches near-peak performance on many machines. PHiPAC uses parameterized code generators, various C coding guidelines, and search scripts that find the best set of parameters for a given architecture/compiler combination to achieve this performance. A source code distribution of PHiPAC is available. It is written in C and will not compile with a non-ANSI C compiler. It can be used with GCC but the performance increase probably won't be nearly as good as with vendor supplied C compilers since GCC does a poorer job of optimizing floating point code than do the latter. I haven't tried to use this yet so I can't comment on this. The package is documented via some technical reports available in PostScript as well as in a set of man pages.

[http://icsi.berkeley.edu/~bilmes/phipac/]

 

PHOTOM

A Starlink Project package for measuring the sky corrected magnitudes and fluxes of astronomical objects within circular and elliptical apertures. PHOTOM can be used to interactively display positions for the measurements or obtain the positions from a file. The aperture can be circular or elliptical and its size and shape can be interactively varied on the display or by entering values from the keyboard. The background sky level is sampled interactively by the manual positioning of an aperture or automatically from an annulus surrounding the object. The program is used by GAIA. A binary distribution of PHOTOM is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. The program is documented in a 28 page user's manual available in PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

PHP

A server-side HTML embedded scripting language that lets you write simple scripts in your HTML source code files like JavaScript although PHP/FI is not browser-dependent. The syntax is mostly borrowed from C, Java and Perl and the goal is to allow Web developers to quickly write dynamically generated pages. PHP is similar in concept to Netscape's LiveWire Pro software with the added features of being fast and free. It can be used as a standard CGI program, as a CGI program with support for the new FastCGI standard, or as an Apache module. The features of PHP include:

• HTTP authentication when it is running as an Apache module;
• access logging by individual users that doesn't use the central access log and provides real-time access monitoring;
• a built-in web-based configuration screen to handle access control configuration that allows various restrictions to be placed on files and directories (including password access);
• support for several database systems including MySQL and PostgreSQL;
• file upload support;
• support for typed variables and associative arrays;
• conditionals and while loops;
• extended regular expressions;
• raw HTTP header control
• on-the-fly GIF image creation via the gd library;
• error handling and error suppression; and
• a PHP source viewer.

The source code for PHP is available and can be installed on any UNIX machine running any UNIX web server. The documentation is available in HTML format at the site and is also included in the distribution. There is also an example gallery at the site that details many possible uses of the software.

[http://www.vex.net/php/]

 

PHREEQC

A C program designed to perform a wide variety of aqueous geochemical calculations. PHREEQC is based on an ion-association aqueous model and its capabilities include: speciation and saturation index calculations; reaction path and advective transport calculations involving specified irreversible reactions, solution mixing, mineral and gas equilibria, surface complexation reactions, and ion-exchange reactions; and inverse modeling which finds sets of mineral and gas mole transfers that account for composition differences between waters.

The improvements of PHREEQC over its Fortran predecessor PHREEQE include: the capability to use redox couples to distribute redox elements among their valence states in speciation calculations; modeling ion exchange and surface complexation reactions; modeling reactions with a fixed pressure, multicomponent gas phase; calculating the mass of water in the aqueous phase during reaction and transport calculations; keeping track of the moles of minerals present in the solid phases and automatically determining the thermodynamically stable phase assemblage; simulating advective transport in combination with reaction modeling; and the use of explicit mole balance equations for hydrogen and oxygen.

A source code distribution of PHREEQC for UNIX platforms is available. Related programs in the USGS Water Resources Application Software series are BALNINPT and NETPATH. The primary documentation is contained within Parkhurst (1995).

[http://water.usgs.gov/software/phreeqc.html]

 

PHRQPITZ

A program for the calculation of geochemical reactions in brines and other highly concentrated electrolyte solutions using the Pitzer virial coefficient approach for activity coefficient corrections. PHRQPITZ is a modification of the geochemical modeling code PHREEQE, the latter of which has been superseded by PHREEQC. The reaction modeling capabilities of PHRQPITZ include: aqueous speciation and mineral saturation index; mineral solubility; mixing and titration of aqueous solutions; irreversible reactions and mineral water mass transfer; and reaction path calculations. The computed results for each aqueous solution include the osmotic coefficient, water activity, mineral saturation indices, mean activity coefficients, total activity coefficients, and scale-dependent values of pH, individual ion activities, and individual ion activity coefficients. A database of Pitzer interaction parameters is provided. A source code distribution of PHRQPITZ for UNIX platforms is available. This is one of the programs in the USGS Water Resources Application Software series. The primary documentation is contained within Plummer et al. (1988).

[http://water.usgs.gov/software/phrqpitz.html]

 

phttpd

A multi-threaded, lightweight, and fast Web server. Phttpd uses features like multithreading, dynamic linking, and memory mapping to achieve quick response time, extensibility, and high transfer rates without consuming huge amounts of system resources. This is presently (1/98) only available for computers running SunOS 5.4 (Solaris 2.4) or later, but it is being ported to other UNIX variants using POSIX threads. [http://home.signum.se/phttpd/]

 

PHYLIP

A collection of programs for performing phylogenies on various types of data such as DNA and protein sequences, restriction sites, distance matrices, gene frequencies, and quantitative and 0-1 discrete characters. The programs are grouped into five functional categories: heuristic tree search algorithms, branch-and-bound tree search algorithms, interactive tree manipulation algorithms, tree plotting software, and software for converting data and making distances or bootstrap replicates. The programs for heuristic tree searching are:

• PROTPARS, which estimates phylogenies from protein sequences using the parsimony method;
• DNAPARS, which estimates by the parsimony method using nucleic acid sequences;
• DNACOMP, which estimates from nucleic acid sequence data using the compatibility criterion;
• DNAML, which estimates from nucleotide sequences by maximum likelihood;
• DNAMLK, the same as DNAML but assumes a molecular clock;
• RESTML, which estimates by maximum likelihood using restriction sites data;
• FITCH, which estimates from distance matrix data under the additive tree model;
• KITSCH, which estiamtes from distance matrix data under the ultrametric model;
• NEIGHBOR, which estimates using the Neighbor Joining Method and the UPGMA (average linkage clustering) method;
• CONTML, which estimates from gene frequency data by maximum likelihood using a model in which all divergence is due to genetic drift in the absence of new mutations;
• MIX, which estimates by some parsimony methodsfor discrete character data with two states; and
• DOLLOP, which estimates by the Dollo or polymorphism criteria for discrete character data with two states.

The branch-and-bound tree search methods include:

• DNAPENNY, which finds all most parsimonious phylogenies for nucleic acid sequences;
• PENNY, which finds all most parsimonious phylogenies for discrete character data with two states for the Wagner, Carmin-Sokal, and mixed parsimony criteria;
• DOLPENNY, which finds all most parsimonious phylogenies for discrete character data for the Dollo or polymorphism criteria; and
• CLIQUE, which finds the largest clique of mutually compatible characters and the phylogeny which they recommend for discrete character data.

The interactive tree manipulation programs include:

• DNAMOVE, for the interactive construction of phylogenies from nucleic acid sequences;
• MOVE, for construction from discrete character data;
• DOLMOVE, for construction from discrete character data using the Dollo or polymorphism parsimony criteria; and
• RETREE, for reading in a tree and allowing rerooting, branch flipping, and changing species names and branch lengths.

The tree manipulation and plotting programs are:

• DRAWGRAM, which plots rooted phylogenies, cladograms, and phenograms in a wide variety of user-controllable formats;
• DRAWTREE, for plotting unrooted phylogenies;
• CONSENSE, which computes concensus trees by the majority-rule consensus tree method; and RETREE.

The data manipulation and bootstrapping programs are:

• DNADIST, which computes four difference distances between species from nucleic acid sequences;
• PROTDIST, which computes a distance measure for protein sequences;
• SEQBOOT, which reads a data set and produces multiple sets for bootstrap resampling;
• GENDIST, which computes one of three difference genetic distance formulas from gene frequency data; and
• FACTOR, which takes discrete multistate data with character state trees and produces the corresponding data set with two states.

All of the programs are written in ANSI C and thus can be compiled and used on generic UNIX platforms with an appropriate compiler. The programs are each documented in separate ASCII text files.

[http://evolution.genetics.washington.edu/phylip.html]

 

phylogeny programs

Available packages include:

• PHYLIP, a package of programs for inferring phylogenies;

[http://evolution.genetics.washington.edu/phylip/software.html]

 

PHYSICA

A package which provides a high-level, interactive programming environment consisting of of a fully procedural programming language with built-in user-friendly graphics and sophisticated mathematical analysis capabilities. PHYSICA provides a wide range of mathematical and graphics operations including almost 200 mathematical functions, over 30 operators, and varied commands for curve fitting, filtering, and smoothing. A dynamic array management scheme allows the use of a large number of arrays of unlimited size, and algebraic expressions of arbitrary complexity can be evaluated. Line graphics, histograms, and pie charts are available as are contour, desnity, and surface plots. A more detailed list of the features of PHYSICA includes: data interpolation of 1- and 2-D data via various methods including linear, Lagrange, weighted splines under tension, and Fritsch-Carlson; smoothing data using weighted splines under tension and Savitzsky-Golay filters; integral transforms of arbitrary expressions; FFTs and inverse FFTs; data reorganization by sorting, stepping, rolling, wrapping, etc.; weighted binning of 1- or 2-D data into automatic or user-defined bins; multiple real roots of an expression; recursive and non-recursive digital filters; manual or automatic determination of data extrema using a graphics cursor; fitting data with an arbitrary, nonlinear expression involving up to 25 parameters; ellipse fitting; calculation of parameters for least squares fits using adjustable parameters; differentiating or integrating arbitrary expressions; and more. Data can be read from and written to ASCII and binary files, with the capability of digitizing data from a displayed plot or a digitizing pad. The built-in language features a macro capability with up to 20 nesting levels and parameter passing, and a macro library of super commands, nested looping, branching, and conditional statements. The graphics capabilities include: multiple graphics windows; any number of graphics on a single picture or window; display on a wide variety of devices including X11 windows, VT640, Tektronix 41xx/42xx, PostScript, GKS metafiles, etc.; over 40 graphics fonts; entry of lines, arcs, and text with dynamic adjustment of position, size, font, and justification; modification of most graphical attributes; area fill functions for arcs and polygons; and more. It is also integrated with the EDGR graphics editor.

Binary versions of PHYSICA are available for VAX/VMS, Alpha/VMS, Digital UNIX, DEC Ultrix, SGI IRIX, Sun SunOS and Solaris, HP-UX, IBM AIX, and Linux Intel platforms. In addition to extensive online help it is documented in a user's manual over 400 pages long available in PostScript format.

[http://www.triumf.ca/compserv.html]

 

PHYS-TeX

A set of TeX macros designed to simplify the formatting and writing of physics papers. There are two formats available, i.e. PHYSE and PHYS, which differ in their hyphenation patterns, one being for English and the other for German. Each format contains macros for automatically numbering chapters and sections, creating appendices, making pages, footnotes, equations, figures, references, and tables. Each can also list all figure captions, table captions, and references as well as generate a table of contents. [http://tug2.cs.umb.edu/ctan/tex-archive/macros/physe/]

 

PHYZZX

A TeX macro package designed to make typing papers for Physical Review or Nuclear Physics as simple as possible. It supports cross-references, automatic numbering of sections and equations, footnotes, itemized lists, and numbered references, tables, and figures. [http://tug2.cs.umb.edu/ctan/tex-archive/macros/phyzzx/]

 

PIA

A program to perform multiple sequence alignment using the parallel iterative improvement method. It first performs tentative alignment for all desired sequences, and then constructs a final alignment using additional biological information. The tentative alignments are performed using a tree-based combination method which can quickly obtain rough correspondence relationships. The modules that comprise PIA are written in C and KL1. The distribution can be compiled and used on generic UNIX platforms on which KLIC has already been installed. A user's manual is included in PostScript format.

[http://www.icot.or.jp/AITEC/IFS/IFS-abst/093.html]

 

Picasso

An interactive drawing tool based on the Tcl/Tk package (which also requires the extended package tclX/TkX as well as the netpbm/pbmplus utilities). Features include greyscale image and PostScript object management with interactive rescaling, rotation, and color control (for PostScript, PPM, GIF, Pict, XBM, XPM, X Window and X Region formats), interactive LaTeX object creation, LateX picture generation mixing PostScript drawing and LaTeX objects, PostScript generation for subparts of a drawing allowing creation of big objects hidden by white objects and selective choice of the interesting region for PostScript generation, and customization possibilities via Tcl. This should install on any UNIX machine on which the required packages are already installed, including Linux boxes. [ftp://zenon.inria.fr/pub/tk/]

 

PICL

The Portable Instrumented Communication Library is a subroutine library which implements a generic message passing interface on a variety of multiprocessors. Programs written using PICL routines instead of the native commands for interprocessor communication are portable in the sense that they can be run on any machine on which the library has been implemented. Correct execution is also a function of the routines called and the parameter values passed to the routines, but standard error trapping is used to inform the user when an operation or parameter value is not legal on a particular machine. Programs written using PICL routines will also produce timestamped trace data on interprocessor communication, processor busy/idle times and simple user-defined events if a few additional statements are added to the source code. A separate facility called ParaGraph can be used to view the trace data graphically. PICL differs from other outwardly similar systems in that it is a compatibility library with an integrated intrumentation package, and because it is intended to be a research tool. PICL supports the writing of portable programs without enforcing it. Machine-specific commands or functionality can still be invoked when necessary to get good performance. Portable instrumentation logic that is integrated with the message passing interface is also a unique feature, one that has proven to be extremely useful. Understanding the performance of a parallel code often requires the collection of both system and user-defined event data. Finally, to be a research tool requires that the code be easy to maintain, easy to extend, and easy to port to new platforms. Every effort has been made to keep PICL simple, and to make it available to other research groups who might be interested in porting it to their multiprocessors.

The PICL source is written in C, but Fortran-to-C interface routines are also supplied for those machines where that is feasible. To create PICL, you need picl2.code. Use uudecode and uncompress to generate picl.shar. Next, unshar picl.shar to create the directory picl2.0. A README file describing how to create the library is located in picl2.0. Supported platforms currently include NX/2 (mpsim hypercube simulator, Intel iPSC/2, iPSC/860, DELTA, Paragon/OSF, and Paragon/SUNMOS), VERTEX (nCUBE/2 and nCUBE/2S), and PVM 3.3 (SUN and RS6000). It is documented in a user's manual, a reference manual, and some technical reports, all of which are available in PostScript format.

[http://www.netlib.org/picl/]

 

Pict

A concurrent programming language based on the pi-calculus. Pict is formed in the ML tradition by adding a layer of convenient syntactic sugar and a static type system to a tiny core. The goal in Pict is to identify high-level idioms which arise naturally when primitives are used to build working programs, e.g. basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on the theoretical foundations for typed, object-oriented languages, e.g. higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm. The Pict distribution contains a Pict-to-C compiler, a reference manual, a language tutorial, numerous libraries, and example programs. It is available either as source code or as an executable binary for Linux Intel and Sun Solaris platforms. Compilation requires the Objective CAML compiler.

[http://www.cs.indiana.edu/hyplan/pierce/ftp/pict/Html/Pict.html]
[http://www.cs.indiana.edu/ftp/pierce/pict/ ]

 

Pike

A high-level, interpreted, and modular object-oriented language. Pike has a syntax similar to that of C and has powerful built-in data types that allow simple and fast data manipulation. The features of Pike include:

• it is interpreted so no compilation and linking are required;
• straightforward and powerful object-oriented features including multiple inheritance;
• extensibility via modules written in C or Pike;
• several powerful, flexible and efficient data types;
• automatic memory management;
• scalability, i.e. it is as useful for small scripts as for large and complex applications;
• text processing capabilities for filtering;
• exception handling; and
• multi-threaded capabilities for application development.

Pike is distributed along with a set of modules for performing various tasks. These modules include:

• Image, an image processing module for performing common operations;
• Sql, an interface to common SQL databases such as PostgreSQL and MySQL;
• MIME, a module for MIME documents;
• Gz, a data compression module; and
• Crypto, a cryptographic toolkit.

A source code distribution of Pike is available as are binaries for several platforms including Linux Intel. A very large manual is separately available in HTML format.

[http://pike.idonex.com/]

PIL

See under Python.

 

PIM

Parallel Iterative Methods is a collection of Fortran 77 routines designed to solve systems of linear equations on parallel computers using a variety of iterative methods. PIM was designed to allow the user complete freedom with respect to the matrix storage, access, and partitioning, and also to achieve portability across a variety of parallel architectures and programming environments. The coefficient matrices may be either real or complex, with PIM routines provided for each in both single and double precision. The routines are designed to allow the use of left-, right-, or symmetric-preconditioning to accelerate or obtain convergence, although they can also be used without preconditioners. The iterative methods included in PIM include: conjugate gradients (CG), bi-conjugate gradients (BICG), conjugate gradients squared (CGS), the stabilized version of BICG (BICGSTAB), the restarted version of BICGSTAB (RBICGSTAB), the restarted generalized minimal residual (RGMRES), the restarted generalized conjugate residual (RGCR), the normal equation solvers (CGNR and CGNE), the quasi-minimal residual (QMR), the transpose-free quasi-minimal residual (TFQMR), and the Chebyshev acceleration (CHEBYSHEV).

The source code for PIM is available. It has been ported to networks of workstations using message passing systems such as PVM and MPI, the SGI Challenge, the KSR1, the Cray Y-MP2E/232, C9016E and T3D, the Intel Paragon, the Intel iPSC/860, the IBM 9070 SP/1, and the TMC CM-5. A user's guide is avilable in PostScript format.

[http://www.mat.ufrgs.br/pim-e.html]

 

PIM (multicast)

The Protocol Independent Multicast is a multicast routing architecture for efficiently establishing distribution trees across wide-area internets where groups are sparsely represented and bandwidth is not uniform due to both the distances and multiple administrations traversed. The robustness, flexibility and scaling properties of PIM make it well suited for use with large, heterogeneous internetworks. [http://netweb.usc.edu/pim/]

 

Pine

A mail user agent (MUA) for UNIX systems. Pine was designed specifically with novice users in mind but can also be tailored to accomodate the needs of more advanced users. The user interface was designed to have carefully limited features, one-character mnemonic commands, always-present command menus, immediate user feedback, and a high tolerance for user mistakes. The features of Pine include:

• online help specific to each screen and context;
• a message index showing a summary including status, sender, size, data and subject;
• several commands to view and process messages;
• a message composer with an editor and spelling checker;
• an address book for saving complex addresses and personal distribution lists;
• message attachments via MIME;
• folder management commands for creating, listing, or renaming message folders;
• access to remote message folders and archives via IMAP;
• Internet news support via either NNTP or IMAP; and
• aggregate operations such as saving a selected set of messages simultaneously.

A source code distribution of Pine is available for UNIX systems as are binaries for several platforms including Linux Intel. A user's manual and several other documents are available in PostScript format.

[http://www.washington.edu/pine/]
[http://sunsite.unc.edu/pub/Linux/system/mail/mua/ ]

 

PinkPanther

A complete enviroment for the automatic benchmarking of document page segmentation algorithms. It consists of three parts: GroundsKeeper, a Motif tool for easily creating and editing segmentation ground-truth; Cluzo, a tool for benchmarking document page segmentation; and segmentation ground-truth, a set of suites of ground-truthed documents used for testing and improving the benchmarking algorithms. The GroundsKeeper tool allows a user to display a document image and draw zones of various types around the different page regions using simple mouse clicks. The zones can be rectangles, constrained polygons, or arbitrary polygons, and can be deleted, moved, or modified after their creation. The created regions are given unique IDs and displayed on the screen. Ordering relationships are specified by clicking on regions in sequence with the sequence identified as a succession of arrows. Cluzo is a region-based approach to benchmarking document page segmentation where quality is assessed by comparing the segmentation output (described as a set of regions together with their types, output order, etc.) to the corresponding ground-truth. The system is flexible and can be customized to benchmark virtually any type of segmentation task.

A source code distribution of the PinkPanther environment is available. It is written in C and requires an X11 environment with the Motif library for compilation and use. The distribution contains documentation for the package.

[http://documents.cfar.umd.edu/resources/source/ppanther/]

 

Piologie

A C++ library for arbitrary precision arithmetic operating on natural and integer numbers. Piologie is portable to all systems and independent of all compilers because it uses only one basic data type which allows the programs to be written in a higher-level language than assembler with no significant loss in speed. It uses the overloading mechanism of C++ and allows mathematical expressions to be written in conventional mathematical form. A source code distribution of Piologie is available. It is written in C++ and can be compiled on just about every available platform/compiler combination via a series of make files supplied. The documentation is currently (11/97) written in German.

[ftp://ruediger.informatik.uni-tuebingen.de/Piologie/]

 

PIOUS

The Parallel Input OUtput System is a complete parallel I/O system for the PVM distributed computing environment. PIOUS implements a fully functional parallel file system on top of PVM similar to how PVM implements a virtual multicomputer on top of a heterogenous network of computers. PVM applications have transparent access to shared permanent storage via PIOUS library functions. This package is intended as both a platform for supporting high-performance parallel applications and as a vehicle for parallel file system research. PIOUS implements the functionality found in most parallel file systems and also has a number of extra features such as: 2-D file objects and logical file views; coordinated file access with guaranteed consistency semantics; data declustering for scalable performance; transaction support and user-selectable fault tolerance modes; extended file maintenance primitives for managing declustered files; and both C and Fortran language bindings.

A source code distribution of PIOUS is available. It is written in C and should compile and install on most UNIX systems which have a PVM installation. It is documented in a user's manual as well as in several technical reports, all of which are available in PostScript format.

[http://www.mathcs.emory.edu/Research/Pious.html]

 

Pipermail

A tool written in Python for maintaining Web archives of mailing lists. [http://starship.skyport.net/crew/amk/maintained/pipermail.html]

 

pipewave

A collection of programs for digital signal processing and auditory modeling that communicate via UNIX pipes. The collection includes programs that generate, transform, and store or plot waveforms, with all communication between programs performed via pipes. The programs in pipewave include:

• add, sums waveform files;
• append, concatenate waveform files;
• autocorr, correlate waveforms;
• bit, bit-shift data in waveform files;
• downsample, downsample data;
• extract, extract part of a waveform;
• fbank, filter data with a gamma-tone filterbank;
• ffilt, filter data in the Fourier domain;
• fft, Fourier transform data;
• fir, create a FIR filter;
• gaussian, generate noise;
• hanning, Hanning window data;
• hilbert, Hilbert transform data;
• histogram, create a histogram of wave sample values;
• ift, inverse Fourier transform data;
• iht, inverse Hilbert transform data;
• jeffress, cross-correlate/cancel data;
• klatt, create a sine wave synthesis of data;
• oversample, oversample data;
• pdp, learn data using 2 or 3 layer PDP nets;
• plot, plot data;
• rms, report statistics of data;
• unwrap, unwrap the phase of a Fourier analysis;
• warp, dynamically time warp a waveform;
• wfc, combine waveform files into multi-channel files; and
• wfs, split multi-channel files into separate files.

A source code distribution of pipewave is available. It is written in C and can be compiled and used on most generic UNIX boxes. Compilation requires a program contained within the |STAT package. Each program is documented in a separate man page.

[http://www.physiol.ox.ac.uk/~jfc/pipewave.html]

 

PIPS

The Parallel Information Processing System converts data between the portable image map format (PNM) and the NetCDF format. PIPS also can perform several operations on NetCDF files in parallel using the PVM message passing package. A source code distribution of PIPS is available. It is written in C and requires the PVM package for its full use. [ftp://prep.ai.mit.edu/pub/gnu/]

 

PISA

The Position, Intensity and Shape Analysis system is a Starlink Project package of routines that deal with the location and parameterization of objects on an image frame. The core of the package is a routine called PISAFIND which performs image analysis on a 2-D data frame. It searches the data array for objects which have a minimum number of connected pixels above a given threshold and extracts the image parameters, e.g. position, intensity, shape, for each object. The parameters can be determined using thresholding techniques or an analytical stellar profile can be used to fit the objects. The deblending of overlapping sources can be performed in crowded regions. PISA can also perform simple object classification by the simple thresholding of an additionally generated peakedness measure or by the multivariate analysis of a set of intensity corrected variables. The other routines in the package include:

• PISAPLOT, which plots the results of PISAFIND as a series of ellipses on a graphics device;
• PISAFIT, which fits the PISA analytic stellar profile to a list of objects;
• PISAGEN, which generates analytic objects and places them in an NDF data array;
• PISAPEAK, which modifies the PISAFIND parameterizations to produce variables which are nearly intensity independent;
• PISAKNN, which performs non-parametric multivariate discriminant analysis on the results from PISAPEAK;
• PISACUT, a utility routine for separating any file into two given a threshold value for a particular variable;
• PISAMATCH, a utility program for matching indices between files;
• PISA2CAT, which converts any of the PISA results files into catalogues which can be used by the CURSA or CATPAC packages;
• PISA2ARD, which converts the results from the PISAFIND routine into an ARD description of ellipses;
• PISAGREY, which plots an NDF data array as a greyscale; and
• ADDNOISE, which adds noise to model data.

A binary distribution of PISA is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. The program is documented in a 38 page user's manual available in PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

Pisces

The Platform for Implicit Surfaces and Curves and the Exploration of Singularities is a project which attempts to supply the mathematical and scientific communities with numerical tools to compute and visualize implicitly defined curves and surfaces. The goals of the project are to create a software package containing: a set of known continuation algorithms for computing implicitly-defined curves and surface included both piecewise-linear and predictor-corrector methods; a command language for batch processing and high level programming; a graphical interface for choosing and controlling algorithms; and new algorithms for computing the structure of singular curves and surfaces. A beta version (5/97) of Pisces is available in source code form. It is written in C and can be compiled and installed on generic UNIX platforms that also have the Tcl/Tk toolkit. The Geomview package is also suggested although not required. The program is documented in several manuals and tutorials available in both HTML and PostScript formats.

[http://www.geom.umn.edu/~fjw/pisces/]

PITCON

See CONTIN.

 

PITSA

The Programmable Interactive Toolbox for Seismological Analysis is a program for the interactive analysis of seismological data. It contains numerous tools for digital signal processing and routine analysis. It is supported on several platforms including Linux Intel. The manual is in PostScript that is inscrutable to GhostScript,m so I haven't much more to say about this right now. [http://lbutler.geo.uni-potsdam.de/service.htm]

 

Pi3Web

A multithreaded, highly configurable and extensible HTTP server and development environment for cross-platform Interner server development and deployment. The features of Pi3Web include:

• easy portability via the use of a platform abstraction library that provides a standard interface to files, shared libraries, threads and synchronization objects;
• configuration files that outline a schema which dictates how loadable classes and objects are linked and nested together;
• a CGI loadable handler for dispatching browser requests to CGI programs;
• a Fast CGI loadable handler;
• a library that provides dynamic loading functionality so server components can be loaded on demand and the server extended without compilation or linking;
• HTTP caching proxy capabilities;
• a thread execution model for higher concurrency with less use of system resources;
• compliance with HTTP 1.0 and some features of 2.0;
• a comprehensive server programming API consisting of libraries providing 189 functions for threads, files, processes, utilities, shared libraries and HTTP functionality;
• an option to allow the reuse of browser-server connections across multiple requests;
• support for server-side includes;
• virtual hosting; and
• customizable logfiles.

A source code distribution of Pi3Web is available as are binaries for several platforms including Linux Intel. Documentation is available in HTML format.

[http://www.johnroy.com/pi3/]

 

Pixcon/Anitroll

Pixcon is a 3D renderer and a set of graphics libraries while Anitroll is an animation system that works with Pixcon. The is no graphical user interface so programs must be run either interactively or via a job script. Pixcon is not a ray tracer, (although it can do a rudimentary and quick sort of ray tracing called ray casting) and, as such, it is much faster than systems that render via ray tracing (although not in real time). The capabilities of Pixcon include a choice of fast polygonal rendering or ray casting (i.e. 1 level deep ray tracing), fake shadows and transparency, the use of 3D texture/shaders, support for 2D texture mapping for most rendering primitives using lerp and mipmaping antialiasing techniques, support for several rendering primitives (e.g. polygons and bi-planes, spheres/ellipsoids, cylinders, cones, surfaces patches, radiant spheres, points/lines, camera, light source, and more), saving rendering as a series of RGB images, rendering to any screen dimension, support for multiprocessing, and more. Anitroll, whose output is designed to be rendered by Anitroll, supports hierarchical forward kinematics with flocking flight and particle behavior for simple animation tasks.

The source code for Pixcon/Anitroll is available and is supported on Linux and IRIX 5.2/5.3/6.0 systems, with the latter assuming the SGI GL library is present and the former using the Mesa GL clone library. The documentation is contained in a manual that comes with the distribution. There is also an online version of the manual.

[http://www.radix.net:80/~dunbar/]

 

pixmap

A pixmap editor for editing, for example, colored icons. The source code is available and should install on generic UNIX/X11 platforms. [ftp://avahi.inria.fr/pub/pixmap/]

 

Pizza

A small and fast compiler for an important superset of the Java language. Pizza also extends Java with three new features: parametric polymorphism which is superficially similar to C++ templates although based on the typing systems of ML and Haskell; first-class functions which may be passed as parameters, stored in variables, and returned from methods; and class cases and pattern matching. Pizza compiles programs to ordinary Java byte code and interfaces with existing Java code, retaining the compatibility of Java. All of the old Java libraries can also be used with Pizza, and binaries can be used as applets. Pizza is implemented on top of the JDK (although other Java-compatible virtual machines will also work). The Pizza compiler pc is a straight replacement for Sun's javac compiler. The pc compiler works just like javac except that it's 2-3 times faster. It can currently be installed and used on UNIX platforms for which a JDK exists as well as on Windows 95 platforms. The language definition and several technical reports are available in PostScript format.

[http://www.cis.unisa.edu.au/~pizza]
[http://cm.bell-labs.com/cm/cs/who/wadler/pizza/
welcome.html ]
[http://wwwipd.ira.uka.de/ pizza ]

 

PLAM

ProLog And Modeling is an implementation of an algebraic modeling language in Prolog. PLAM exploits the natural advantages of using logic programming for mathematical programming tasks, and allows the user to formulate problems in a high-level and declarative manner. Prolog predicates can be used to incorporate familiar algebraic notation, and the system will automatically generate the corresponding input for a mathematical programming solver. The source code distribution of PLAM will run under either the commercially available SICStus Prolog or the freely available SWI-Prolog. It supports the built-in solver of the SICStus implementation as well as the commercial CPLEX solver and the freely available lp-solve. The language and the ideas between it are documented in a technical report available in PostScript format.

[http://www.mpi-sb.mpg.de:/~barth/plam/plam.html]

 

PLAN

The Programming Language for Active Networks is a resource-bounded functional programming language which uses a from of remote procedural call to realize active networking. It is designed to be a public, authentication-free layer in the Active Network hierarchy, and as such its expressive power is limited to guarantee that all programs will terminate and reasonably permit a router to run any PLAN program. PLAN can also be used as a glue layer which allows access to higher-level services, with the combination of both allowing much of the flexibility of active networking without sacrificing security. An Active Network is one which allows routing elements to be extensively programmed by the packets passing through them which enables optimizations and extensions of current protocols as well as the development of fundamentally new protocols. A source code distribution of PLAN is available. It is written in Java and contains the Java class files, source code, documentation, and sample programs. The JDK 1.1.1 Linux port is needed as well as the Pizza class files to use this package. Compiling the code from source additionally requires the JavaCC parser generator. The documentation includes an installation guide, a tutorial, and a programmer's guide, all available in PostScript format.

[http://www.cis.upenn.edu/~switchware/PLAN/]

 

Plan 9

A distributed computing environment assembled from separate machines acting as terminals, CPU servers, and file servers. The components are connected via various kinds of networks, e.g. Ethernet, Datakit, modem connections, ISDN, etc. Typically, users interact with applications that run either on their terminals or on CPU servers, with the applications getting data from file servers. Plan 9 is an operating system written from the ground up. It is strongly influenced by UNIX but not a replacement for it. It is designed to fully exploit three basic ideas: (1) all the system objects present themselves as named files that are manipulated by read/write operations; (2) all these files may exist either locally or remotely and respond to a standard protocol; and (3) the file system name space is dynamically and individually adjustable for each of the programs running on a particular machine. This means that application programs don't need to know where or on what kind of machine they're running. Plan 9 is highly portable and runs on four major machine architectures (including x86 Intel). It supports symmetric multiprocessing in that both the CPU and file servers are multi-processor machines. The distribution includes compilers for C and other languages along with all of the commands and program development tools found in the UNIX environment. It also provides some new software tools including: Alef, a new language providing threads, inter-process and inter-machine communication via typed channels, and abstract data types; Acid, a programmable debugger that understands multiple process programs; and Acme, a new user interface in which any word on the screen can be interpreted as a command by clicking on it, and any string can specify a file to be displayed.

Various parts of the Plan 9 system have been emulated on UNIX/X11 platforms. These include: Wily, a mouse-oriented, text-based working environment based largely on Acme; Sam, a multi-file screen editor with structural regular expressions; rc, a re-implementation of the Plan 9 shell; 9wm, an X11 window manager emulating the Plan 9 window manager called 8 1/2; 9term, an 8 1/2 terminal emulator; and 9menu, a program that allows the creation of X menus from the shell where each menu item will run a command (which can be used from 9wm or any other window manager). See 9 (1995) and 9 (1995).

[http://plan9.bell-labs.com/plan9/]

 

PLAPACK

The Parallel Linear Algebra PACK is a library infrastructure for the parallel implementation of linear algebra algorithms and applications on distributed memory supercomputers such as the Intel Paragon, IBM SP2, Cray T3D/T3E, SGI PowerChallenge, and Convex Exemplar. This infrastructure allows library developers, scientists, and engineers to exploit a natural approach to encoding so-called blocked algorithms, which achieve high performance by operating on submatrices and subvectors. This feature, as well as the use of an alternative, more application-centric approach to data distribution, sets PLAPACK apart from other parallel linear algebra libraries, allowing for strong performance and significantly less programming by the user. The initial release of PLAPACK is due on March 20, 1997, at which time I'll attempt to supply further details. The documentation is contained within a book recently published by the MIT Press and, to a lesser extent, within some reports and papers available at the site.

[http://www.cs.utexas.edu/users/plapack/]

 

PLinda

Persistent Linda is a programming environment for writing fault-tolerant distributed/parallel program that run on networks on workstations. PLinda is a set of extensions to the Linda parallel programming model, and PLinda/C++ and PLinda/Fortran are implementations combined with those sequential languages. The key design issues of PLinda are:

• fault tolerance capabilities wherein applications can be built such that they will survive failure during execution and finish their appointed tasks;
• effective use of workstations wherein the PLinda parallel virtual shared memory machine, whose processors are idle workstations, uses only those processors that are idle, adding and subtracting those that become idle or busy;
• high performance wherein fault tolerance can be customized for each application such that performance is maximized.

A source code distribution of PLinda is available. Installation requires GCC 2.6.3 or above and Tcl/Tk 3.6 or higher.

[http://merv.cs.nyu.edu:8001/~binli/plinda/]

 

plm2c

A PL/M-286 to C converter. [http://www.ccil.org/retro/retromuseum.html]

 

plonk

A Scheme bytecode interpreter which although minimal is almost fully R4RS-compliant. This is available as either a Java runtime application or as Scheme source code. [http://www.well.com/user/djello/]

 

Plotmtv

A fast multi-purpose plotting program for X-windows. It allows the construction of 2-D line and scatter plots, contour plots, 3-D surface, line and scatter plots as well as vector plots. It should install reasonably easily on any platform running X-windows. [ftp://tanqueray.eecs.berkeley.edu/pub/]

 

PlotPlus

A general purpose, interactive, command driven, scientific graphics package. The features of PlotPlus include: support for multiple output devices including X11, PostScript, GIF, MPEG, and HDF animation files; a powerful and flexible scripting language; support for multiple input formats including ASCII, binary, and NetCDF; integration with nccalc for NetCDF reading, writing, and calculations; generation of MPEG animations using the Berkeley MPEG-1 software encoder; several data display options including X-Y line plots, contour plots, and color area fill; several map projections including Mercator, Polar Stereographic, and Peters; linear, log and time axes; colored labels, plot lines, and contour lines; and more. A source code distribution of PlotPlus is available. It is written in Fortran and C and can be compiled and used on most UNIX platforms. It is documented in a user's manual available in PostScript format. See also the EPIC package which uses this for plotting.

[http://www.halcyon.com/www2/dwd/]

 

Plotter

The AthenaTools Plotter Widget Set is a set of widgets to add graphs to X programs. It provides many of the features needed to embed a scientific or business graph into another program. This set is based on Xlib and Xt and is intended to be used with other widget sets based on the same, e.g. Xaw or Motif. It is not 3-D and cannot do pie charts or other non-XY type graphs. The features of the widget set include: X-Y plots for scientific graphics; line and bar plots for business-style graphics; the automatic or manual scanning of axis values and the automatic selection of tic marks; flexible text facilities including mathematical symbols, sub- and super-scripts, font changes, etc.; an unlimited amount of plots on each graph with each independently specified; generation of EPS which closely matches screen output; the use of either linear or logarithmic axes labeled at arbitrary points with arbitrary strings; flexible axis handling with up to four axes on each graph; a fast update mode which can quickly redraw rapidly changing data; easy access to application data stored in an array of structures; and more.

The source code of the Plotter library is available. It is written in C and can be compiled on most generic UNIX/X11 platforms via the Imakefile in the distribution. Demonstration programs are included for both Motif and Xaw. The library is well documented in both man pages and a PostScript user's guide included in the distribution.

[ftp://ftp.uni-paderborn.de/unix/tools/]

 

plotutils

The GNU plotting utilities are a collection of programs for plotting 2-D scientific data. The major part of the collection consists of a set of programs collectively known as graph, i.e. graph-X, graph-ps, graph-fig, graph-tek, and raw graph. Each version of graph reads one or more data files and outputs a plot to a display device or a file, with the versions differing only in the output devices they support. The graph-X version opens an X Window and draws a plot therein; graph-ps produces a plot in PostScript; graph-fig produces output that may be displayed and edited with the Xfig drawing editor; graph-tek produces output that can be displayed on a Tektronix 4014 terminal or emulator; and raw graph produces output in a device-independent format referred to as a GNU plot files. Five programs collectively called plot translate these GNU plot files into the various output formats: plot2X, plot2ps, plot2fig, plot2tek, and plot2plot (with the latter compatible with the non-GNU versions of graph supplied with some systems). Other programs in the plotutils package include: spline, which performs spline interpolation of data using cubic splines or splines in tension (and can also function as a real-time filter); and ode, which can integrate an ODE or a system of ODEs when provided with an explicit expression for each equation. A library of subroutines called libplot for device-independent 2-D vector graphics is also included (with both graph and plot built on top of this). A version of this library exists for each of the above formats.

A source code version of plotutils is available. It is written in C and can be installed on a wide variety of platforms using the configure file included in the distribution. Its use is documented in a user's manual included in Texinfo format.

[ftp://ftp.digital.com/pub/GNU/]

 

PLplot

A library of C functions that are useful for making scientific plots from a program written in C or Fortran. PLplot can be used to create x-y, log, semilog, loglog, contour, and mesh plots as well as bar and pie charts. The kernel of PLplot was based on PGPLOT but the code was not derived from it. The authors have designed it to be an inexpensive and portable way to create scientific graphics. PLplot capabilities include placing multiple graphics on the same page with multiple lines on each; support for many different types of line styles, widths and colors; many kinds of area fill patterns; a generous choice of fonts and font sizes including Greek letters and mathematical symbols; and support for a wide number of output devices including X Windows, Tektronix, PostScript, etc. It also has an interactive driver written in Tcl/Tk that can be used to manipulate a graph, e.g. zooming, panning, scaling, orienting, changing colors, etc. PLplot has bindings that allow it to be used in both Fortran and C programs. zoom, pan, scale, orient, and change colors on the same page with multiple lines on each. A wide variety of line styles, widths, colors and fill patterns are available as well as many characters in an extended character set. Many different output device drivers are available, including a portable metafile format and renderer. A Tcl/Tk GUI is currently being developed.

The source code is available and has been compiled on generic UNIX platforms as well as on VMS, Amiga, MS-DOS and NeXT platforms. There is a user's and reference guide available in PostScript format that describes how to use the package and details the individual subroutines, although the most recent version lags behind the software itself.

[ftp://dino.ph.utexas.edu/plplot/]

 

PLTMG

A package for solving an elliptic partial differential equation in general regions of the plane. It features adaptive local mesh refinement, multigrid iteration, and a pseudo-arclength continuation option for parameter dependencies. The package includes an initial mesh generator and several graphics packages. The source code is contained in several files. Both single and double precision versions are provided in directories single and double respectively. The file pltmg.f contains the majority of the routines, which are machine independent and should compile on a wide variety of computers (Apple, Cray, DEC, SGI, Sun, IBM) with no modification. The file machdep.f contains four machine dependent routines, namely PLTUTL, PLINE, PFILL, and TIMER; these routines may have to be modified for your local environment. The provided source code is set up to use graphics drivers for an X-Window System color workstation (xgraph.c), and a PostScript driven laser printer (psgraph.f). Graphics drivers for Sunview, MacIntosh, Silicon Graphics, and IBM PC have also been implemented. The documentation is contained in Bank (1996).

[http://www.netlib.org/pltmg/index.html]

 

Plug-and-Play

A set of specifications, often abbreviated PnP, which allow a compatible device to be recognized and its hardware resource requirements examined or changed, with the hardware resource requirements being DMA channels, I/O ports, IRQ signals, and memory addresses. Kernel patches are available (in various states of usefulness) to enable such things to be done by Linux. There is also a package called isapnptools which allows PnP devices to be configured on a Linux machine. [http://www.redhat.com/linux-info/pnp/]

Plugger

See under Netscape.

 

Plume

Web browser implemented using Tcl/Tk. This will parse HTML up to a subset of HTML V3.0 in its Alpha incarnation, and is planned to be fully 3.0 compliant. Plume will download and execute Tcl scripts a.k.a. applets in a manner similar to the Java package. This used to be called SurfIt. [http://tcltk.anu.edu.au/SurfIt/]

 

plusFort

A toolkit for Fortran programmers. The Linux version is somewhat limited in functionality but free for academic and commercial evaluation use. It does not have any time or size restrictions and contains all of the restructuring and static analysis capabilities of the standard version. It can handle F77 and most common extensions, including all of VAX Fortran. Excluded features include coverage and dynamic analysis, clutter removal, F77-F90 translation, variable renaming, complexity metrics, and SQL and ICETRAN parsers. [http://www.polyhedron.co.uk/pflinux.html]

 

Plush

A general purpose 3-D graphics library designed for efficiency, rendering quality, and overall ease of use. The features of version 1.1 include:

• 8 bpp palettized rasterizers (for triangles only);
• an Open Rasterizing Architecture (ORA) which makes it easy to use other rasterizers with Plush or write your own wrappers for hardware acceleration;
• several fill modes including solid, translucent, affine environment mapped, perspective environment mapped, affine texture mapped, perspective texture mapped, and others;
• several shade modes including Lambert, Gouraud, Phong, Distance Gouraud, and distance flat shading;
• hidden surface removal;
• full 3-D frustrum clipping by polygon splitting with automatic retesselation;
• an unlimited number of cameras with full camera control (i.e. six degrees of freedom);
• an unlimited number of lights;
• point or directional lights;
• support for precalculated lighting;
• handling of materials by automatic palette mapping and management;
• a PCX texture reader;
• automatic texture rescaling and palette optimization;
• an nth dimensional spline interpolator for smooth motion;
• tension, continuity and bias controls;
• generation of primitive objects; and
• readers for 3DS, COB, and JAW meshes.

A source code distribution of Plush is available as are binaries for several platforms including Linux Intel. The code is written in ANSI C and can be compiled on a wide variety of platforms. Several example programs are available.

[http://www.nullsoft.com/plush/]

 

PM

The Prolog/Mali system is a compiler for the logic programming language LambdaProlog, an extension of standard Prolog in which terms are simply typed lambda-terms. This can be used in the same types of applications as standard Prolog, and is especially good for applications where the scoping of variables is important, e.g. theorem proving, implementation of type systems, formal transformation of structured programs, etc. The PM system is a compiler writer in PM which produces C code, with the execution system using Mali, an abstract memory for representing terms with efficient space management. The PM systems is available either as source code or as a binary for Sun SunOS, HP-UX, or Linux Intel platforms. The distribution consists of the compiler, the libraries, a user's manual in PostScript format, and some examples.

[ftp://ftp.irisa.fr/local/pm/]

 

PMPIO

A portable implementation of the MPI-IO interface. PMPIO is a tool for refining the MPI-2 I/O chapter specification and a base for developing vendor implementations of MPI-2. The interim beta release is not intended for production use. The current (5/97) version of PMPIO features: full support for arbitrary filetypes (data distributions), MPI compatible datatype constructors for common distributions, collective I/O operations optimized via collective buffering, 64 bit support, support for info objects cb_nodes and cb_buffer_size, error handling, and full C and Fortran 77 interfaces. Additional features which may be included but aren't in the current (5/97) beta release are: asynchronous I/O, atomicity operations, shared file pointers, profiling, support for files stored on NFS file systems, support for MPICH, and support for PMPIO ALPHA based codes.

[http://lovelace.nas.nasa.gov/MPI-IO/pmpio/pmpio.html]

 

PM2 High Perf

The Parallel Multithreaded Machine is a portable multithreaded environment providing execution support for highly parallel applications. The PM2 programming model is based on threads and the Lightweight Remote Procedure Call (LRPC) mechanism, and it is distinguished by such features as a priority driven scheduling policy, thread migration mechanisms, and the ability to permit easy development of various load balancing policies. It is built on top of a communication package (currently (2/98) PVM, MPI, TCP, or BIP) and a process library called MARCEL. MARCEL is a user-level thread package designed to provide a large subset of the POSIX standard thread interface primitives along with some additional features, e.g. dynamic stacks and migration. The PM2 environment provides a computing model based on lightweight processes that allows the exploitation of heterogeneous configurations. Remote functionalities (e.g. remote creation, etc.) were added to a standard threads package to provide special functionalities for parallel computing (e.g. dynamic stack resizing, thread migration, stack caching, etc.). It consists of an LRPC mechanism that forks a remote thread to execute a specified service. Three types of LPRCs are available. A synchronous LRPC is equivalent to a classical RPC except that code is execute by a remote thread in another process. It is blocked until it gets back a result and thus can't initiate further parallelism. An asynchronous LRPC is a method of efficiently initiating remote threads since it involves only sending a message and no waiting for results to return. A deferred waiting LRPC decomposes the LRPC in two steps: (1) an LRP Call (asynchronous creation of a remote thread) and (2) an LRP Wait (waiting for results). This allows the generation of real parallelism since several LRP Calls can be triggered without waiting for results to return.

A source code distribution of PM2 is available. It can be used on several platforms including Alpha OSF-1, Sun Solaris and SunOS, Linux Intel, SGI IRIX, and PowerPC/AIX. The documentation is currently available only in French although English versions are promised.

[http://www.ens-lyon.fr/~rnamyst/pm2.html]

 

Pmw

Python megawidgets is a framework for building high-level compound widgets in Python using the Tk graphics library. It provides a method for obtaining a consistent look and feel between graphical applications and is highly configurable. Pmw consists of a set of base classes and a library of flexible and extensible megawidgets built on the base classes, e.g. ButtonBox, ComboBox, MessageDialog, etc. Other features include: a lazy importer/dynamic loader which is automatically invoked when Pmw is first imported which gives unified access to all Pmw classes and speeds up loading time; complete documentation of megawidget options, methods, and components; a test framework and tests for both the Tkinter module and all the Pmw widgets; a demo of all the widgets; and an interface to the BLT busy, graph and vector commands. A source code version of Pmw is available. It is written in Tk and Python and also requires the Tkinter package. Full documentation is included in the package and is also available onsite.

[http://www.dscpl.com.au/pmw/]

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