Up: Linux Software Encyclopedia
Last checked or modified: Oct. 29, 1998
- Portable Network Graphics is
a format for portable graphics, as you might surmise from the
name. PNG unofficially stands for PNG's Not GIF,
from the decision of Unisys and CompuServe to require royalties
from programs using the GIF format since Unisys has a patent on
the LZW compression format used therein.
The main advantages which PNG has over GIF are:
It also compresses better in almost every case, with the
difference generally ranging from 10% to 30%.
Since PNG is intended to be single-image format only, it
doesn't feature multiple-image support.
PNG also has the advantage that it has one and only one
official pronunciation, i.e. ``ping.''
- alpha channels (variable transparency),
- gamma correction (cross-platform control of image brightness), and
- 2-D interlacing (a method of progressive display).
Standard PNG features include:
- support for three main image types, i.e. truecolor, grayscale, and
palette (with JPEG
supporting the first two and GIF only the third);
- compression filters which are a way of transforming the image
data (losslessly) so it will compress better; and
- file integrity checks, e.g. an 8-byte magic signature at the beginning of
every image, a 32-bit cyclic redundancy check, and an Adler-32 checksum
applied to the complete stream of uncompressed data.
PNG-related software includes:
Web browsers which support the PNG format include
- libpng, the PNG library;
- xpaint and
- A companion library to the PNG
specification written to reduce the amount of time and effort
it takes to support said specification.
Libpng is designed to handle multiple simultaneous sessions,
to be easily modifiable, and to be portable to most machines.
It uses zlib for the compression and
decompression of PNG files.
The source code for libpng, written in C, is available and
should compile on most machines since that is a design goal.
It is documented in an ASCII file included with the distribution.
- A batch-mode compression utility for PNG images.
This reduces the size of the PNG datastream by trying various
compression levels and filter methods.
- PNG Magick
- See under the
Netscape entry since
this is a Netscape plug-in.
- See Pbmplus.
- A scripting language for the
It was designed to provide a simple interface to manipulate Java
objects and to be called easily from Java programs, and is particularly
useful for debugging and prototyping.
The features of Pnuts include:
A source code distribution is available which requires
JDK 1.1 or better.
- full access to all public members and constructors of the Jav API
(although it lacks the capability of defining classes);
- an expression-based (i.e. interpreted) environment;
- integration of primitive and reference data types;
- a pseudo list notation implemented as an array of objects;
- functions that can take an arbitrary number of parameters and which
are identified by the name and number of parameters;
- no typing of variables, i.e. no declarations; and
- packages that provide naming scopes.
- The Portable Object Compiler is described in the
- A program which takes one or multiple Perl
POD files and produces a single PostScript
file. It can be run on single or multiple files from the
command line or using a script or command file.
The output includes PDFMARK operators that can be used by the Adobe
Acrobat Distiller program to produce a fully indexed PDF file.
- A text editor specifically designed
to use the mouse as much as possible in editing. Point
provides convenient ways to keep a number of windows open
on files and to copy text between and within files using
The features of Point include:
- an unlimited number of windows and files;
- easy moving and copying within and among windows;
- complete configurability including menus, key bindings, titles, etc.;
- extensive options for modifying the look and feel;
- the use of Tcl/Tk as a macro language and
- several searching options including for selection, last string searched
for, a regular expression, the last regular expression, a string in a
list of files, or a C tag;
- file browsers;
- circular mouse menus, i.e. gesture commands; and
- unlimited undo, redo, and again.
A source code distribution of Point is available.
It is written in C with compilation and use also requiring
Tcl 7.0 or greater or Tk 3.3 or greater.
It is documented in a user's guide available in
PostScript format as well as
in a man page. A brief FAQ is also included.
- A package of Fortran 77 routines for the rapid
solution of certain types of elliptic equations in rectangular and
Specifically, solutions are found for the nonseparable self-adjoint
elliptic problem in 2-D polygonal domains with Direchlet boundary
conditions. Helmholtz and Poisson problems in polygonal domains
and the general variable coefficient problem in a rectangular domain
can be treated as special cases of this.
The solution method combines the use of the capacitance matrix
method (for treating the irregular boundary) and an efficient
iterative method (using the Laplacian as a preconditioner) to deal
Each iterative step thus involves solving the Poisson equation
in a rectangular domain.
This is TOMS algorithm 732 and is documented
in Cummins and Vallis (1994).
- A framework and package for the hardware-software co-design of
embedded systems, especially those which are control-intensive,
reactive, real-time systems.
Examples of the types of systems for which POLIS is designed
included microwave ovens, cameras, telephone switches, cellular
phones, engine controllers, anti-lock brake controllers,
robots, and plant monitors.
The POLIS system is based around a single finite state machine-like
(FSM) representation called a co-design finite state machine (CFSM).
The CFSM transforms a set of inputs into a set of outputs with only
a finite amount of internal state.
It differs from FSMs in that the synchronous communication model of
the FSM is replaced by a finite, non-zero, unbounded reaction time
model in the CFSM. This model can be described as globally
asynchronous and locally synchronous, with CSFM specifications
a priori unbiased towards either a hardware or software implementation.
The chief advantage of the abstract CFSM model is that is covers the
behavior of all possible hardware-software implmentations at once.
In POLIS specifications are written in a high-level language
such as Esterel that is directly translated
The formal specification and synthesis methodology uses many
of the methods available for CSMs (e.g. VIS)
which are applied via the
inclusion of a translator from CFSMs to FSMs.
The methodology also incorporates a set of abstraction and assumption
rules specific to CFSMs and POLIS which makes is possible to verify
designs larger than was previously possible.
A co-simulation process is used which lets the designer test a wide
range of choices for hardware/software partitioning and CPU and schedular
selection, with the Ptolemy package currently
used as a simulation engine.
The portions of the CFSMs chosen for hardware implementation are
optimized using logic synthesis techniques from the
The portions to be implemented in software are mapped onto a software
structure which includes a procedure for each CFSM together with a simple
real-time operating system.
The reactive behavior of the CFSM portions is synthesized by first
implementing and optimizing the desired behavior in a high-level,
processor-independent form similar to a control/data flow graph,
which is then translated into portable C code for further optimization
on a given compiler.
An application-specific OS consisting of a schedular and I/O drivers
is generated for each partitioned design.
The interfaces between the hardware and software domains are automatically
synthesized within POLIS, and come in the form of cooperating circuits
and software procedures embedded in the synthesized implementation.
A source code distribution of POLIS is available as are
binaries for several platforms including Linux Intel.
The source can be compiled on most UNIX flavors using
the GCC compiler.
The documentation includes a user's manual in
- A general purpose animation system particularly well-suited to building
animations of programs, algorithsm, and computations (especially
parallel computations). POLKA provides its own high-level
abstractions to make the creation of animations easier and faster
than with many other systems, with programmers not needing to be
graphics experts to develop animations.
It includes an interactive front-end called SAMBA which is an
animation interpreter that reads ASCII commands or animation
directives and performs them.
A source code distribution of POLKA is available. It is
written in C++ on top of
UNIX and X11 and requires either the Motif
or Xaw widget sets.
It is documented in a technical report available in
- A Starlink Project package
for the interactive data analysis of linear spectropolarimetric
A linear polarization spectrum is a set of Stokes vectors which
means that spectropolarimetric data is 4-D (and 6-D if the variance
arrays of the Stokes parameters are included) and cannot be
manipulated using standard spectral analysis packages.
POLMAP is designed for the specific needs of these data sets.
TRIPLOT is a command for the flexible display of
polarization spectra. It displays triplots which consist of a
top panel showing the position angle of the polarization in
degrees, a middle section showing the percentage polarization,
and a bottom section showing the intensity spectrum.
A polarization spectrum may also be plotted in the QU plane
using the QUPLOT command.
Other commands include MERGE to merge two stack polarization
spectra, ISFIT to fit a Serkowksi law to the data using
a nonlinear least squares method (in order to subtract the
interstellar polarization vector from the intrinisic polarization
spectrum), and FITPA and PACALIB for PA calibration.
A binary distribution of POLMAP is available for DEC OSF/1,
Linux Intel, and Sun Solaris platforms.
It is documented in a user's manual available in
- A plane-parallel fully-polarized atmospheric radiative
transfer model. This package contains separate versions,
one for solar or thermal radiation in a medium of randomly
oriented particles and one for thermal radiation in a medium
of azimuthally symmetrically-oriented particles.
The codes are written in Fortran and documented in
ASCII README files.
- A Fortran 90 code for solving N complex
coefficient polynomial systems of equations in N unknowns using
a probability-one, globally convergent homotopy method.
The package consists of two modules:
This also requires some routines from
- GLOBAL_PLP, contains the derived data types that define
the polynomial system, the system partition, and the start system of
the homotopy; and
- POLSYS, contains the actual solver and its internal
routines as well as the routines responsible for root counting.
- A filter for UNIX man pages.
It takes as input man pages
formatted for a variety of UNIX
flavors (not [tn]roff source)
and produces as output a variety of file formats, e.g. ASCII,
TkMan, [tn]roff, Ensemble,
LaTeX, RTF, etc. This
is written in ANSI C and should compile on any
UNIX box with
a C compiler, including Linux.
This used to be called RosettaMan.
- Polynomial Toolbox
- The latest version of this (version 2) is a commercial product, and
no freely editions are available.
A Matlab toolbox for performing many types
of computations with and on polynomial matrices.
The functionality of the toolbox includes:
Documentation is available in PDF format.
- defining polynomial matrices;
- performing operations on polynomial matrices, e.g. transforming them
to canonical forms such as Hermite, Smith, echelon, row, column and
diagonally reduced forms;
- computing determinants and zeros;
- performing operations such as addition and multiplication;
- performing spectral factorization and computing null spaces;
- modeling linear time-invariant systems and transforming
polynomial representations thereof to and from other representations;
- solving linear polynomial matrix equations; and
- solving various types of control problems such as pole placement,
H-2 and H-infinity optimization.
- A C program implementing boundary elements to provide
solutions to boundary value problems of continuum mechanics.
Poly3D calculates the displacements and strains and stresses in an
elastic whole- or half-space using planar, polygonal-shaped
elements of displacement discontinuity.
Polygonal elements may have any number of sides (with a minimum of three),
and parameters are calculated at specified points or grids defined
by the user.
Model fractures and surfaces are treated as surfaces of displacement
discontinuity (opening or slip). Slip distributions on faults subject
to tectonic loading can be calculated as well as the stress and
displacement fields around the faults.
- The Princeton Ocean Model is a
sigma-coordinate, free surface, primitive equation ocean
circulation model which includes a turbulence sub-model.
It is written in Fortran 77
and is documented in a large manual
in PostScript format.
- Parallel Object-Oriented Methods and
Applications is an object-oriented framework for developing
applications in computational science that require high performance
parallel computers. It is implemented as a library of
C++ clases designed to represent the common abstractions
found in such applications.
It is designed to achieve high performance on both single processor
and shared-memory multiprocessor machines.
This is accomplished by presenting the data parallel programming
interface at the highest abstraction layer and encapsulating distribution
and communication of data among processors in lower implementation layers.
This means that codes developed on serial workstations port to all
The current (12/98) release provides multidimensional arrays using
a wide variety of storage schemes and parallel decompositions,
multithreading, and out-of-order execution for maximum performance.
Planned features include fields, coordinate systems, particles, and
parallelism on distributed memory multicompters and networks of
workstations using MPI.
See Reynders III (1998).
- POP (ocean)
- The Parallel Ocean Program ocean circulation
model is a descendant of the Bryan-Cox-Semtner class of
finite-difference models, with several improvements that
improve both the computational performance and the physical accuracy.
This is written in Fortran 90 and requires
an appropriate compiler.
- a formulation of the barotropic surface mode based on surface
pressure (rather than the streamfunction) which allows any number
of islands to be included at no additional computational cost as
well as more realistic, unsmoothed bottom topoography to be used
with no reduction in time step;
- an implicit free-surface boundary condition that allows the
air-sea interface to evolve freely and makes sea-surface height
a prognostic variable;
- latitudinal scaling of horizontal diffusion which prevents
the time step from being severely limited at high latitudes while
keeping diffusion large enough to maintain numerical stability;
- pressure gradient computation via a linear combination of three
time levels, allowing the time step to be increased;
- use of domain decomposition in latitude and longitude as well
as MPI for ease of use and increased efficiency
on parallel machines;
- use of general orthogonal coordinates in the horizontal, allowing
alternatives to bypass the usual singularity at the North Pole; and
- a displaced-pole grid that moves the singularity onto a land
- In systems using the Post Office Protocol mail is
delivered to a shared server, with client programs periodically connecting
to the server to download all pending mail. This is called a
store-and-forward service that moves mail on demand from an
intermediate server or drop point to single destination machines.
The protocol is described in RFCs 1734,
1957, 2095, and 2195.
Software capable of acting either as a POP mail server or client
- An implementation of the Post Office Protocol (POP) which
runs on a variety of UNIX computers to manage electronic
mail for Mac and MS-DOS computers.
The features of Popper include:
an idle timeout,
a bulletin board,
an xlst (extended list) command,
an uidl (unique identifier list) command,
an authorization file,
logging of mail sent via POP to mail debug,
MMDF handling (autodetection),
large site support, i.e. a server mode,
a database for bulletin tracking, and
Kerberos enabled no enabelable by a switch.
A source code version of this is available with makefiles
for many flavors of UNIX included.
The package is documented in man pages.
A shadow password version of this can be found in the
Shadow Ina Box tool suite.
- A PPTP server that allows Linux servers to
function seamlessly in a PPTP VPN environment.
The current (5/99) release supports Windoze 95/98/NT clients and
PPTP Linux clients.
The eventual full release will support all Windows clients with a
full range of encryption and authentication features.
- A source-to-source compiler that translates C programs into those
capable of saving and recovering from portable checkpoints.
These checkpoints can be transferred in heterogeneous computer
networks such as the Internet and may be restarted on binary
This has been successfully tested on several systems including
- PORT (Bell)
- The Portable, Outstanding, Reliable and Tested
mathematical subroutine library is a large collection of mathematical
subroutines written in Fortran.
It covers most traditional areas of numerical mathematics except
In addition to the mathematical routines, there are several non-numeric
routines that constitute what is called the Framework of the library.
The Framework consists of error handling, memory stack allocation, and
machine-constant specific routines that underly the mathematical
routines and contain the platform specific features.
The mathematical routines of PORT are divided into several categories
- approximation routines for performing best uniform approximation
with rational splines, interpolation with splines, least squares
approximation to discrete functions, and best uniform approximation
to continuous functions;
- differential equation routines for both stiff and nonstiff ODEs;
- linear algebra software including eigenvalue routines,
basic linear algebra modules, least squares routines, and linear
equation solving programs;
- optimization routines for
minimizing functions with one or more
- partial differential equations in one spatial variable and time;
- quadrature programs for performing numerical integrations;
- root finding programs for finding zeros of polynomials, single
real roots of functions, single roots of complex functions, and roots
of a set of nonlinear equations;
- special functions including all elementary functions defined in
the ANSI 66 Standard Fortran Library, Bessel functions, and the gamma
- fast Fourier transforms; and
- utility functions including random number generators, arithmetic
utilities, functions for evaluating expressions in terms of orthogonal
polynomials, operations on 1-D arrays, and printing functions.
A source code distribution of the PORT library is available under
a limited use non-commercial license.
It is written in Fortran.
Documentation is available in PostScript format.
- PORT (Netlib)
- A library of Fortran routines for performing various
tasks. The full PORT3 library is a commercial product available
from Lucent Technologies, although a subset of the routines is
An important part of the subset is a set of three subroutines which
handle machine dependencies for integers, real numbers, and
double precision numbers and which are called, respectively, i1mach,
r1mach, and d1mach.
The subset also includes
Also available in the public version of PORT are up-to-date
versions of NL2SOL as well as extended variants, i.e.
n2f, a version of NL2SNO;
n2g, a version of NLSSOL;
n2p, a variant of NLSOL that allows the residual
vector and Jacobian matrix to be passed in piece rather than
all at once;
n2[fgp]b, versions of NL2SOL that handle simple bounds;
ns[fg], versions for separable nonlinear least squares;
ns[fg]b versions for separable nonlinear least squares with
simple bounds; and
dn[s2][fgp][b ], double precision versions of the above.
There are also versions of the SMSNO, SUMSL, and
HUMSL algorithms for general unconstrained minimization, e.g.
mnf, which uses function values only;
mng, which uses function and gradient values;
mnh, which uses function, gradient, and Hessian values;
mn[fgh]b, versions of the above which handle simple bounds; and
dmn[fgh][b ], double precision versions of the above.
- port numbers
- Special or reserved port numbers are assigned to various
Internet protocols or services. For
example, port 80 is
almost always reserved for HTTP,
port 0 for TCP and UDP, and
port 119 for NNTP.
Many of the numbers from 0 to 1023 are reserved in this way, with quite
a few more so-called Registered Ports existing in the range
1024 to 65535.
See the lists of:
- The POlyhedron Representation Transformation
Algorithm package is
a collection of
optimization routines for analyzing polytopes
and polyhedra given either as the convex hull of a set of
points (plus the convex cone of a set of vectors) or as a system
of linear equations and inequalities.
PORTA guarantees correct numerical results since only integer
operations are performed.
If an arithmetic overflow occurs using integer arithmetic
then the computations are restarted using double precision
The programs in the package include:
- traf, which
performs a transformation from one of the two representations to
the other using a Fourier-Mortzkin elimination algorithm which
projects a linear system onto subspaces;
- vint, which enumerates all of the valid
integral points within given bounds;
- fctp, which
checks the facet inducing property of a set of linear inequalities
for a polyhedron given as a convex hull plus a convex cone;
- dim, which computes the dimension of a polyhedron
given as a convex hull plus a convex cone; and
- portsort, which
sorts and formats given system to improve the readability
A source code distribution of PORTA is available. It is
written in C and is documented via man pages.
- A program that scans TCP ports.
The features include strobe-scanning support for faster scanning
of standardized network services and subnet scanning to iteratively
scan for ports on all machines on a subnet simulteneously.
A source code distribution is available.
- A system for port scan detection and active defense.
This part of the Abacus Project suite of security tools is designed
to detect and respond to port scans against a target host in real time.
The novel features of PortSentry include:
A source code distribution is available.
- configurability to run on multiple, simultaneous
TCP and UDP sockets so one
copy can cover dozens of tripwired services;
- stealth scan detection, e.g. detection of SYN/half-open, FIN,
NULL, X-MAS and oddball packet stealth scans;
- reaction to port scan attempts by blocking the host in real time
via either dropping the local route back to the attacker or dropping
the attacking host IP into a TCP Wrappers hosts.deny file;
- an internal state engine to remember previously connected hosts; and
- reporting all violations to local or remote syslog daemons
including the system name, time of attack, attacking host IP, and hte
port through which the attempt was made.
- A software tool for modeling and simulating arbitrary discrete and
discontinuous systems. It can also handle suitably discretized
POSES++ supports the analysis of existing or planned systems
and optimizes them by creating various variants of the system
and comparing their performance.
It can also be used to generate complex control software by creating
a model containing the optimal algorithms for controlling a system,
and then creating a binary version of that model for the actual
system being modeled.
The modeling is based on high level Petri Net definitions.
POSES++ can most obviously be applied to the field of logistics,
i.e. the safeguarding of investment decisions, the shortening
of development cycles, the optimization of such systems, etc.
The POSES++ system consists of several components which each offer
flexible and extensible interfaces to other POSES++ tools as well as
to external software.
The collection of tools comprises a multiserver-multiclient
structure whose components communicate using
TCP/IP via a command-line interface.
The components include:
External evaluation tools such as spreadsheets or math packages
can also be used by POSES++ via an appropriate interface.
- an Editor used to generate and process models based
on a modular design concept with each model capable of being
used independently or as a sub-model of some larger model;
- a Compiler that checks the syntactic correctness of the
source file and then uses it to generate the model needed by
the simulation kernel for evaluation of the rules which
can also create efficient binary codes for varous hardware
and software combinations which represents the executable
- an Animator and Layout Editor which are used to generate
graphical animations of system processes;
- a Simulation Kernel which executes the simulation models
created by the Compiler and handles necessary communication
with the other components; and
- an Experiment Tool which supplies the functions needed to execute
simulation experiments, e.g. contacting the simulation kernel,
selecting the desired model, handling debugging and tracing, etc.
Binary distributions of POSES++ are available for
DEC OSF/1, Sun SunOS, HP-UX, and Linux Intel platforms.
A user's manual is available in either
- The Portable Operating System Interface is
a set of operating system standards.
It is an attempt by a
consortium of vendors to create a single standard version of
UNIX and is intended to define an operating system which behaves
like UNIX whether or not it really is UNIX.
The POSIX.1 standard defines the System Application Program
Interface, i.e. the C procedure calls used in writing programs for
The POSIX.2 standard defines the Shell and Utilities and is heavily
dependent on POSIX.1.
The POSIX.2 standard is the one which will be used to implement
The major aspects defined by the POSIX.2 standard are:
the Execution Environment Utilities, e.g. cat, kill, etc.;
the User Portability Utilities, e.g. more, vi, etc.;
the Software Development Utilities;
the C Development Utilities;
the shell command language;
language-independent interfaces for high-level programming languages; and
definitions, general requirements, and the UNIX environment, i.e.
locales, guidelines for utility command-line syntax, system-wide
environment variables, and regular expressions.
The complete POSIX standards (as of 6/97) are (where a designation of
the form POSIX.n is short for IEEE 1003.n):
Other POSIX standards which follow a slightly different numbering
- POSIX.0 - guide to POSIX (+)
- POSIX.1 - system API for the C language (+)
- POSIX.1a - system API extensions (e.g. symlinks, etc.)
- POSIX.1b - real-time and I/O extensions (formerly POSIX.4) (-)
- POSIX.1c - threads (formerly POSIX.4a) (-)
- POSIX.1d - more real-time extensions (formerly POSIX.4b)
- POSIX.1e - security extensions and ACLs (formerly POSIX.6)
- POSIX.1f - transparent network file access (formerly POSIX.8)
- POSIX.1g - protocol independent communications and sockets (formerly
- POSIX.1h - fault tolerance
- POSIX.1i - technical corrections to POSIX.1b (-)
- POSIX.1j - advanced real-time extensions
- POSIX.1k - removable media API
- POSIX.1m - checkpointing and restarting
- POSIX.1n - fixes to .1, .1b, .1c and .1i
- POSIX.1q - tracing
- POSIX.2 - shells and common utility programs (+)
- POSIX.2a - more tools and utilities (-)
- POSIX.2b - more utilities
- POSIX.2c - security utilities
- POSIX.2d - batch processing utilities (-)
- POSIX.2e - removable media utilities
- POSIX.5 - Ada binding to POSIX.1 (+)
- POSIX.5b - Ada binding to POSIX.1b (-)
- POSIX.5c - Ada binding to POSIX.1g
- POSIX.9 - Fortran 77 binding to POSIX.1 (+)
- POSIX.10 - supercomputing profile (+)
- POSIX.13 - realtime profile
- POSIX.14 - multi-processing profile
- POSIX.18 - POSIX profile
Finished and published standards are marked with (+),
extensions which have been included in the latest edition of
the corresponding main standard are marked with (-), and
all others are in the draft stage.
Changes in POSIX standard status are announced in
comp.std.unix, and the current status can be viewed
at the first given URL.
See Zlotnick (1991), Lewine (1991), and
- IEEE 1387 - system administration
- IEEE 1387.1 - overview
- IEEE 1387.2 - software administration (+)
- IEEE 1387.3 - user/group account administration (+)
- IEEE 1387.4 - printer administration
- IEEE 2003 - test methodology (formerly POSIX.3)
- IEEE 2003.1 - test methods for POSIX.1
- IEEE 2003.1b - test methods for POSIX.1b
- IEEE 2003.2 - test methods for POSIX.2
- A library containing implementations of some of the functions
defined in the POSIX.1b standard that
aren't as yet (12/98) present in Linux.
These include clock, realtime timer, semaphore, shared memory and
message queue functions.
The timers are emulated using the BSD interval timer API and
the other functions via standard System V IPC.
- Panther Open Source Software for
Linux is an application development environment for building
transactional, component-based web applications. Its extensible
framework decreases the technical complexity of building distributed
applications by providing visual tools, an object repository and
application building blocks.
The features include:
- an import utility to automatically create application objects from
- a screen wizard for generating complex data access forms;
- database drivers for automated result set management, data mapping
between user interface and databse, and integration with database metadata;
- a transaction manager for automatically generated SQL, managed
application modality, and optimized SQL including that for multi-table
joins and outer joins;
- an EJB component builder for drag-and-drop building of components
and automatic generation of component interfaces;
- team development, debugging, version control and advanced reporting
- a class library of pre-built classes, methods and components to
jumpstart application development.
The Panther framework provides all the tools nedded for building n-tier
client/server applications. The development tools include:
- a graphical editing environment for creating screens, reports and
service components (specifically EJBs) using widgets such as pushbuttons
and data entry fields;
- a visual object repository consisting of a central library for creating,
storing and accessing objects used for building applications;
- a library facility for storing all the objects used in an
- a menu bar editor for designing menu bars and toolbars;
- a testing environment and built-in debugger; and
- a networked library and repository access for cohesive and controlled
software development, including repository-stored application objects,
interfaces to third-party source control, and access to libraries on
The available deployment tools include:
Tools for database access and support include:
- programming language options including the Panther scripting language
(JPL), Java or C for adding
programming logic to screens, service components and reports;
- a styles editor for assigning styles that define an object's color
and protection based on the current transaction.
Tools for middleware access and support include:
- drivers for several database engines;
- the ability to import database definitions into a repository;
- a single-user JDB SQL database for use as a
prototyping tool for testing and refining multi-user database
- a runtime transaction manager that performs the processing needed
to view and update database information.
- a middleware adapter for connecting the middleware that manages
communication between the client and server so the data can be passed from
client to middleware, middleware to server, and back again;
- the capability of creating service components (i.e. EJBs) to
communicate with the IBM WebSphere software; and
- runtime support for integration with WebSphere.
- A mathematical tool for the representation and manipulation of finite
partially ordered sets (i.e. posets). Possum is designed especially
for providing tools for domain theory and the construction of approximations
to semantic domains, but can be useful to anyone with an interest
in order theory.
It can produce Hasse diagrams of the posets that it generates via
interaction with the daVinci visualization
The diagrams are displayed on the screen and can be interactively
fine-tuned. They can also be exported as PostScript for
Interaction is either through the daVinic GUI or a command-line
interpreter which uses the
Objective Caml language.
The latter allows complicated expressions involving posets to be
A source code distribution of Possum is available.
Installation requires daVinci 2.0.3 or
later and Objective Caml 1.05
The use of the program is documented in several online HTML
documents and the algorithms used in a technical report
available in PostScript format.
- A program for scaling and tiling a PostScript image for printing on
Poster can be used to create a large poster by building it from
multiple pages and/or printing it on large media.
A source code distribution of this C program is available.
It is documented via a man page.
- An MTA intended as a replacement for
Postfix attempts to be fast, easy to administer, and secure as well as
compatible enough with sendmail to not
upset existing users.
The features of Postfix include:
- performance up to three times as fast as its nearest competitor;
- behaving rationally under stressful conditions, e.g. if the system
runs out of disk space or memory it backs off rather than make the
- flexibility via a dozen or so programs that each perform only
one specific task robustly and efficiently;
- security via multiple layers of defense to protect the system
- eventual support for multiple transports although the initial
release only handles SMTP with some support
- support for virtual domains such that adding support for one
requires changing only a single lookup table;
- UCE control wherein Postfix can restrict what hosts can relay
mail through it, and support for restrictions on what mail is allowed
to enter; and
- extensive use of table lookups rather than the implementation of
an address rewriting language.
Several daemons are used by Postfix including:
- master, the resident daemon that runs the other daemons
on command in a manner similar to inetd with network processes;
- smtpd, the SMTP server;
- smtp, the SMTP client;
- bounce, the message bouncing or deferring daemon;
- pickup, the daemon that waits for hints the new mail
has been dropped into the maildrop directory;
- qmgr, the queue manager daemon that waits for the arrival
of incoming mail and arranges for its delivery;
- trivial-rewrite, a daemon that handles requests to
rewrite and resolve addresses;
- local, a daemon that processes delivery requests from the
queue manager to deliver mail to local recipients; and
- cleanup, a daemon to canonicalize and enqueue inbound mail.
Postfix contains several command-line programs for performing
various tasks including:
- sendmail, a Postfix to sendmail
- mailq, lists the mail queue;
- newaliases, initializes the alias database;
- postfix, controls the operation of the mail system;
- postalias, maintains alias databases (and is used
- postcat, displays the contents of queue files;
- postconf, displays the main configuration file parameters;
- postdrop, the mail posting agent run by the sendmail
command on systems with no world-writable maildrop queue directory;
- postkick, makes internal communication channels available
for use in, e.g. shell scripts;
- postlock, provides mailbox locking;
- postlog, provides logging;
- postmap, maintains lookup tables; and
- postsuper, maintains the Postfix queue.
Source code distributions of Postfix are available as both
stable official releases and experimental releases.
Documentation is mostly via man pages.
- An enhancement of the POSTGRES database
management system (DBMS),
a next-generation DBMS research prototype.
PostgreSQL retains the data model and data types of POSTGRES while
replacing the PostQuel query language with an extended subset
of SQL. Other enhancements include a program (psql) which supports
GNU readline, a new front-end library
(libpgtcl) which supports Tcl-base clients,
a sample shell (pgtclsh) which provides new Tcl commands to interface
Tcl programs with the PostgreSQL backend, a major overhaul of the
large object interface, and more.
The features of PostgreSQL that distinguish it from conventional
data managers include:
- inheritance, i.e. a class can inherit from
zero or more other classes and a query can reference either all
instances of a class or all instances of a class plus all of its
- time travel, i.e. a feature that allows a user to
run historical queries by specifying a time range; and
- non-atomic values, i.e. attributes can themselves contain sub-values
that can be accessed from the query language, e.g. you can create
attributes that are arrays of base types.
The source code for PostgreSQL, written in C, is available and
can be compiled using gcc. It has been successfully tested on
DEC Alpha, DEC Ultrix, Sun SunOS and Solaris, HP/9000, and
Linux Intel platforms.
An article about PostgreSQL can be found in the February 1998
issue of the Linux Journal.
- A graphical database query tool developed using
- A free database management tool for PostgreSQL.
The functionality includes:
Source and binary distributions are available.
- opening multiple tables for viewing;
- column resizing;
- text wrap in cells with the layout saved for every table;
- importing from and exporting to external files;
- filtering and sorting;
- editing in place;
- a table generator assistant;
- defining, editing and storing user-defined queries;
- storing queries as views;
- execution of queries with optional input parameters;
- query deleting and renaming;
- a visual query builder with drag and drop capabilities;
- defining, inspecting and deleting sequences and functions in SQL;
- designing and displaying simple reports from tables;
- saving and loading report descriptions from a database;
- a form design module;
- defining, modifying and calling user-defined scripts; and
- defining and modifying user parameters.
- A PostgreSQL driver for
- A Python module that interfaces to a
It is object-oriented, easy to use, and has several extensions
for building GUIs and interfacing with the Web.
- A mail user agent (MUA) called the
``swiss-army-knife of command-line mailers'' by its author.
The features of POSTIE include:
A source code distribution of this C++ program
is available as are binaries for selected platforms including Linux Intel.
This is free for personal use.
- sendmail compatibility for input streaming;
- multipart file attachment/extraction;
- sending and receiving HTML mail;
- support for file-based mailing lists;
- inter-host mail relaying;
- mailbox masquerading wherein multiple users transparently share a
single mail account;
- Usenet news posting;
- file attachment via wild card file specifications;
- NNTP authentication support;
- list server processing, i.e. creating public or private mailing lists;
- file server processing, i.e. fetching files via email;
- uuencoding/decoding of files and attachments;
- IMAP4 support including posting;
- embedding objects in HTML mail; and
- SSLv3 and TLSv1.
- A mail user agent based on
TkRat with the addition of several
features including robust support for IMAP
in a shared folder environment.
This uses IMAP mailboxes to support multiuser environments with system-wide
configurations, mailboxes and address books, and shared folders.
The source code distribution requires Tcl/Tk
8.0p2 as well as several common image libraries.
- A programming language
optimized for printing graphics and
text. It is a page description language wherein individual
pages or images are described in a device independent manner
within the source code. It is also a stack-based language,
resembling an RPN calculator (e.g. the HP series). A good
introduction to the language and its operators is
A First Guide to PostScript
which is available in both hypertext and
PostScript formats. There is also a
PostScript Tutorial and Reference
in PostScript format.
Useful resources include:
Useful PostScript-related software includes:
The October 1997 issue of the
Linux Journal contains an
article about PostScript.
- a2ps, which converts ASCII text into
PostScript and sends it to a printer or a file;
- Distillery, which ensures that a PostScript
document follows the Adobe DSC.
- dvips, a program that converts TeX .DVI files into
- enscript, which converts text files to
- epssplit, splits an EPS file into
several smaller EPS files;
- fontutils, which can convert PostScript
fonts to TeX TK format;
- Ghostscript, an interpreter;
- Ghostview, a previewer;
- Groff, which converts troff source into PostScript;
- hp2xx, for converting HP-GL graphics into
- ImageMagick, an image conversion package;
- impose++, a set of programs for printing
two-up versions of PostScript files;
- Lout, a typesetting system;
- poster, for creating multiple page posters;
- PPST, a
benchmarking program for PostScript printers;
- PreScript, a PostScript to plain
text converter which can also produce rudimentary HTML;
- PSPLOT, a library of Fortran-callable
routines for creating PostScript graphs;
- psrepair, for repairing common defects
in PostScript files;
- pstoedit, which converts PostScript and PDF
files into other vector graphics formats;
- pstoepsi, for converting PostScript into
- pstotext, which converts PostScript files
into ASCII text files;
- PSTricks, a collection of
macros compatible with most TeX macro packages;
- psutils, a set of
utilities for resizing and various other tasks;
- Quikscript, a portable typesetting system
written in PostScript;
- TinyDict, for PostScript processing that
typesets ASCII text into various formats for self-printing books
on laser printers; and
- Zone, a library of 3-D PostScript operators.
- The Persistence Of
creates 3-D, photo-realistic
images using a rendering technique called ray tracing. It reads in
a text file containing information describing the objects and lighting
in a scene and generates an image of that scene from the view point
of a camera also described in the text file. It can also add greater
realism to images via a process known as radiosity. It produces
very high quality images with realistic reflections, shading,
perspective and other effects.
The file containing the scene image description cannot be created with
the POV-Ray package. This must be done with a separate package
that allows you to visually arrange structures.
The features of POV-Ray include:
- an easy to use description language;
- a large library of example scene files;
- standard include files
that pre-define many shapes, colors and textures;
- high quality
output image files in 24-bit color;
- creation of landscapes using
smoothed height fields;
- spotlights for sophisticated lighting;
- phong and specular highlighting for more realistic looking
- many basic shape primitives;
- Constructive Solid Geometry
for easily combining simple shapes into complex shapes;
- many built-in color patterns, surface bump patterns, and textures; and
- combinations of textures.
A generic UNIX source code version is available as well as binary versions
for Linux, DOS, Mac and Amiga platforms. The documentation
is available in both HTML and PostScript formats. Also available
are ancillary packages such as
for distributing calculations across several platforms.
- A program that allows POV-Ray to distribute
rendering tasks across many machines.
This connects to each machine, sends an
archive containing all the files needed to render a scene, and tells
each machine to do a small piece of the image.
The features include:
A source code distribution is available.
- a curses-based progress display on the server machine;
- handling more than one job simultaneously;
- dynamicallly adding and removing machines;
- server state saving so the job can be stopped and started at
any time; and
- a UDP heartbeat signal for detecting whether
machines are down.
- A front-end for POV-Ray that aims to
provide an easy way to launch POV rendering with a graphical
interface that manages all of the available options, including those
that are ostensibly script-only.
This is part of the GIRAM project.
- A graphical interface for POV-Ray
created using Tcl/Tk.
The components include a toolbar for launching applications,
a text editor specializing in the POV-Ray language,
a tool for visualizing colors, and a window for changing
- A terminal emulator that supports many terminal windows embedded into
a single X11 window, with each given its own notebook tab.
The features include:
- full GNOME support;
- menu options to open a new tab with various programs running;
- changing menu options via .pshellrc as well as via the
preferences dialog box;
- switching terms via CTRL-1, CTRL-2, etc.;
- support for transparency and pixmap backgrounds;
- full support for color; and
- URL handling.
- The Portable Parallel Branch-and-Bound
Library offers an easy way to parallelize sequential branch and
bound algorithms for several architectures.
No knowledge of hardware architecture or parallelization mechanisms
is needed to use PPBB-Lib.
Each parallel running process of the B&B application maintains the
point of view of the sequential algorithm, with the library taking
over the management of the subproblems creating during execution.
Load balancers provided by the library ensure a balanced distribution
of the subproblems.
It is designed to run on an distributed memory multicomputer architecture
using the given message passing functions and a C compiler.
Binary versions of PPBB are available for both sequential and shared
memory Linux Intel platforms as well as for several supercomputer
It is documented in a user's manual available in PostScript format.
It can be obtained by filling in an online request form.
- The POSIX Portable Common Runtime package
provides integrated user-level support for pre-emptive lightweight
collected storage, and dynamic program loading.
PPCR can take advantage of kernel thread extensions in the
underlying system and should run on any
POSIX.1-conforming implementation which
also supports BSD select() or System V poll().
It also uses memory protection features available in some
systems to support incremental garbage collection.
The source code is available and has been successfully built
on Sun SunOS and Solaris, SGI IRIX, Linux Intel, and BSDI platforms.
PPCR is documented in an ASCII file in the distribution.
- The parallel predictor-corrector package is a parallel version of
the PCx package.
The source code is written in C with
MPI extensions and should be
released soon (4/97).
- An advanced encrypted file system for Linux Intel platforms.
It is used in a manner similar to the loop device and offers
simplicity, speed and full strength 128-bit encryption.
A combination of master/working pass phrases offers enhanced
security for backup copies.
The latest version allows root filesystem encryption to ensure
that no plaintext data is left on the disc.
This is currently (1/99) in beta test stage and consists of
a kernel patch plus some support programs.
- The Parallel Portability Interface in C++
is an object-oriented
message-passing library. It is designed to serve as a stable interface
between the client parallel code and the rapidly evolving distributed
computing environments. By taking advantage of encapsulation,
inheritance, and polymorphism supported by C++, PPI++ provides a clean
and consistent programming interface which helps improve the clarity
and expressiveness of client parallel codes and hides implementation
details and complexity from the user to ease parallel programming tasks.
To benefit fully from the functionalities, portability, and efficiency
provided by MPI, the
present implementation of PPI++ uses MPI functions
to achieve interprocess communication and synchronization. However,
the C++ user interface of PPI++ is designed to be very light weight
and independent of MPI.
The source code for PPI++, written in C++, is available.
The package is documented in several technical reports available
in PostScript format and also in Hsieh and Sotelino (1997).
- Abbreviation for the Portable PixelMap graphics
This is used in the Pbmplus package.
- A parallel make utility which attempts to run as many parts
of a large set of make jobs simultaneously on different
computers connected by PVM as is
Ppmake requires on changes in makefiles, and
can be used as easily as starting PVM on each participating
computer and typing ppmake instead of make.
The features include interrupt handling, setting timeouts,
setting prefix commands, counting jobs, and calculation
and display of the degree of parallelism.
The ppmake software is available as source code.
It's use requires GNU make as well as PVM.
- A conversion program which
converts PPM, PGM, and PBM pictures into FLI animations and
vice-versa. This is supposed to be a replacement for
- The Point-to-Point Protocol is an Internet standard
for the transmission of IP packets over serial
(e.g. modem lines.
It is designed for simple links transporting packets
between two peers with the links providing full-duplex simultaneous
The three main components of PPP are: (1) a method for
encapsulating multi-protocol diagrams; (2) a link control protocol
(LCP) for establishing, configuring and testing the data-link
connection; and (3) a family of network control protocols (NCP) for
establishing and configuring different network layer protocols.
PPP-related software includes:
- diald, a dialing daemon for Internet connections;
- eznet, a program that automatically sets up and
- EzPPP, a Qt front-end
- gppp, a GTK front-end
- IsinGlass, a script for making PPP
connections more secure;
- masqdialer, a daemon for initiating and
terminating dialup Internet connections;
- pppd, a PPP daemon package;
- Visual PPP, a
Tcl/Tk front-end to PPP.
- A package for implementing PPP.
The package consists of two parts:
The daemon also includes support for authentication.
A source code distribution is available which is also included in
most standard distributions.
- kernel code that establishes a network interface and passes
packets between the serial port, the kernel networking code, and
- the daemon (pppd) that negotiates with the peer to establish
the link and set up the PPP network interface.
- A UNIX print spooler designed for operating
PPR is a research project designed to explore the possibilities
of the Adobe Document Structuring convention, PPD files, and
automatic filtering with the goal of making printing easy
for end users.
The features of PPR include:
- operation of printers connected to parallel and serial ports,
AppleTalk, LAN Manager X clients, LPD servers, and RAW TCP/IP
- capture of messages returned by the printer while
a job is printing (if the printer interface supports it);
- sending notices to users when jobs are completed or when they
- detection of printer faults and automatic attempts
to clear them;
- interpretation of Document Structuring Convention (DSC)
comments to support advanced features such as printer redirection,
reverse order printing, collated copies, font downloading, font
substitution, and forced duplex mode;
- passing print jobs through
Ghostscript before sending them to
print PostScript files on non-PostScript printers;
- automatic detection of non-PostScript output and passage through
appropriate filters (e.g. Netpbm,
TeX, and Groff);
- automatic detection and decompression of compressed files;
- printer queue advertising on AppleTalk networks;
jobs for AT&T's LAN Manager for UNIX;]
- acceptance of jobs from
other computers using the LPD protocol and from the
Samba LAN manager;
- display of job
percentage done in the queue listing; and
- printing banner pages.
The code is currently being developed on a Linux system and
has also been tested on DEC OSF/1, SGI IRIX, *BSD, and
Sun SunOS platforms.
The documentation includes installation and user's manuals
(available in PostScript and HTML format) and an extensive
set of man pages.
- A GUI for PPP created using
- A PostScript printer
This tests a printer for the various things it's supposed to
do and creates a set of output pages, one for each specific
range of tasks. These include:
- a bitmap image test that prints three images - two color and
one black and white;
- a graphics test that tests various graphics operators;
- a font test that prints various available fonts;
- a memory test that tests the speed of the printer RAM by
copying variables from one part of memory to another;
- a math test that tests the various mathematical operations; and
- a final page containing the statistics for each of the other pages.
- The Point to Point Tunneling Protocol is used
by Windows NT/95 platforms to create Virtual Private Networks (VPNs).
It makes use of the Generic Routing and Encapsulation (GRE) protocol
as defined in RFC 1701 and 1702.
- A tool that searches for patterns conserved in a set of protein
sequences. The kinds of patterns to be searched for can be specified
as well as the number of sequences that should match a pattern.
Other features include:
A source code distribution of Pratt is available which is written
in C and can be compiled on most platforms.
A manual is available in HTML format.
- command line search control wherein values for all parameters
can be specified on the command line;
- use of upper- and lower-case symbols to differentiate
sequences matching wildcard and non-wildcard positions;
- extensive online help;
- restriction of search areas;
- input of multiple sequence alignments of some or all sequences
in a set of protein sequences; and
- use of branch-and-bound heuristics to make pattern searches
- A Fortran 77 function subroutine that returns
the minimum of a function F(X,N) of N variables using the
principal axis method. The gradient of the function is not
- The Project Revision
Control System is the front
end to a set of tools that provide a way to deal with sets of
files and directories as an entity to preserve coherent versions
of entire sets. It presents the abstraction of named projects
that have multiple versions, each consisting of a set of files
arranged into a directory subtree. PRCS attempts to provide
a much simpler model than similar packages like RCS or CVS.
The operations allowed by the software include creating a copy
of the directory tree for a project version, creating a new
project version, searching for differences between project
versions, inserting changes that occurred between two project
versions (i.e. merging), printing out information about
project versions, adding or subtracting the files contained
in a new project version, moving files from one subdirectory
(i.e. version) to another, etc. PRCS keeps track of all checked-in
project versions in a repository and locks them in only while it
is actually running.
The source code of PRCS is available as are binaries for
FreeBSD, HPUX, IRIX, Linux ELF, Solaris, SunOS and ULTRIX
platforms. The present (9/96) documentation is contained
within a hypertext document at the site (in HTML format).
- The PREttier Compiler Compiler eXtended
is an infinite-lookahead
dependent grammars which generates ANSI C code.
Specification scripts are in very extended BNF with inherited
and synthetic attributes allowed.
Scripts can be compiled in separate modules and later linked
together, and meta-production rules are allowed.
The technology is essentially LL(oo) with optimizations, and
a converter for yacc scripts is available.
Lexical analyzers such a lex and flex are suitable pre-filters
for PRECCX and are called in the same way that yacc calls them.
A significant feature of PRECCX is the use of parameterized
grammar definitions which allow context-dependent grammars.
The higher order capability provided by parameterization and the
modular arrangement of scripts make parser specifications much
more maintainable. The infinite lookahead feature makes the
semantics declarative, e.g. a non-terminal can be replaced by
its definition without altering the semantics.
A newer feature is that attributes can be synthesized on the
fly and passed seamlessly into the parser, which extends
the declarative programming paradigm from parameterized attribute
grammar specifications to fully cover mixed and/or synthetic
attributed grammars as well.
A distribution of PRECCX is available for Linux platforms.
It is documented in a user's manual available in
- The PRecision Estimation and Control In
Scientific and Engineering computing package is a
set of Matlab tools for setting up and
performing computer experiments to explore the impact of finite
precision on the quality of convergence of numerical methods.
Numerical stability experiments are performed by a straightforward
randomization of selected data, after which a sample of perturbed
solutions (or spectra) and associated residuals are calculated.
Complete statistical backward error analyses can also be performed
on numerical methods.
The Matlab routines in PRECISE include:
- rnorm, for normwise data perturbations;
- rcomp, for componentwise data perturbations;
- statinv_comp, for componentwise statistical studies of
- statinv_norm, for normwise statistical studies of matrix
- statlu_comp, for componentwise statistical study of
linear systems using LU factorization;
- statlu_norm, for normwise statistical study of linear
systems using LU factorization;
- statqr_comp, for componentwise statistical study of the
solution of linear systems using QR factorization;
- statqr_norm, for normwise statistical study of the
solution of linear systems using QR factorization;
- graphlin, for the graphical display of experiment results;
- stateig_norm, for normwise statistical study of eigenvalues;
- grapheig, for graphical display of eigenvalue studies;
- stat_newt, newt, pol, derpol, perpol, for
componentwise statistical study of Newton iteration;
- graphnewt, for graphical display of Newton experiment results;
- pscomp, for componentwise perturbed spectra;
- psnorm, for normwise perturbed spectra; and
- portrait, couleur, resolv, forme, for obtaining
and graphing the spectral portrait of a matrix.
- A program for the transparent encryption of email whose goal is to
add privacy and authentication to existing email clients with a
minimum of fiddling while preserving a rich set of functionality
including MIME-based multimedia data types.
The features of premail include:
creation and management of newnym style nyms,
some support for S/MIME using RIPEM
as the cryptographic engine,
integration with Netscape 3.0,
support for all cypherpunk remailers,
support for Mixmaster remailers,
encrypted and signed email including both preparation and decoding,
support for the PGP/MIME standard,
support for MOSS through TIS/MOSS 7.1,
automatic selection of remailer chains,
clean handling of ``cc:'' field and other such interactions,
A source code distribution of premail is available.
It is written in Perl and requires
version 5 or greater.
Documentation is available online.
- A preprocessor for Fortran programs which is an alternative
The features include full macro facilities, a concise
shorthand for array and vector statements,
and support for all of the standard flow control constructs
The vector statement notation makes it possible to incorporate
do loop unrolling automatically to any depth.
The macro processor is a sort of pre-preprocessor for which
the order of translation is file inclusion, macro processing,
flow control extensions, and vector statements.
A source code distribution of PREP is available.
It is written in portable C and can be compiled and used
on most generic UNIX platforms.
Its use is documented in a user's guide in ASCII format.
- A preprocessor for
The features include:
The drawbacks include not understanding preprocessor constructs
other than #include and no support for namespaces.
- transformation of unit-style single source file C++ modules into
three output files, i.e. a public header, a private header, and an
- automatic expansion of class declarations using member function
definitions found in the input file;
- automatic exporting of functions declared inline, along with all
the functions and types they need; and
- preservation of all comments.
- Available preprocessing languages and utilities include:
- abc2mtex, can be used as a preprocessor
for MusicTeX or
- Basis, includes a Fortran preprocessor;
- bibprep, a preprocessor for bibliographical
- CHPP, a preprocessor originally designed for
HTML but much more widely applicable;
- cpp, a part of astkit that is
a standalone preprocesssor for C;
- doxygen, a documentation system with a
full C preprocessor;
- Dynace, a preprocessor for adding object-oriented
features to C;
- ELROS, a C preprocessor that produces remote
operations from embedded statements;
- EPP, an extensible Java
- fastpictex, a preprocessor for
- GCC, the GNU C compilation system;
- gtml, an HTML preprocessor;
- HMML, an HTML preprocessor;
- HTE, an HTML preprocessor;
- HTeX, a preprocessor for embedding
LaTeX equations in HTML;
- htmlpp, an HTML preprocessor;
- igor, a configuration file preprocessor;
- iPP, a general preprocessor written
- MPP, a preprocessor for creating MPEG movies;
- Ox, a yacc/lex/C preprocessor for
bringing attribute grammars to mainstream UNIX;
- PREP, a Fortran preprocessor;
- Preprocess, a preprocessor for
- RATC, a preprocessor for updating the
control structures in C;
- RATFOR, the classic Fortran preprocessor;
- Reactive-C, a language implemented
as a C preprocessor;
- SEPlib, a package containing preprocessors
for Fortran code;
- WPP, an HTML preprocessor; and
- Y, designed as a replacement for
- A utility that converts PostScript to plain ASCII or HTML.
It first converts a PostScript document to plain text and then
inserts rudimentary HTML tags to partly automate the conversion
of PostScript documents into HTML.
PreScript also determines the line spacing of a document and uses
that and indentations to determine paragraph boundaries, removes
hyphenations where needed, and detects and translates most ligatures.
It is written in PostScript and Python and requires
Ghostscript 4.01 or later and
Python 1.3 or later.
- presentation software
- Package for creating transparencies and/or onscreen presentations
for those inevitable and mostly useless meetings and conferences.
Listed packages include:
- EWIPE, a Tcl/Tk-based
package for creating presentations
- LaTeX, which has several macro packages for
creating presentation slides;
- Lout, which has a macro package for
creating presentation slides;
- Lyx, a front-end for LaTeX
which makes using it somewhat easier for neophytes;
- MagicPoint, for creating presentations on
X11 screens and PostScript slides; and
- xdvipresent, a system for creating
slide presentations with LaTeX and X11.
- A prettyprinter generator that creates modules for prettyprinting
from the grammars for various languages including C, Pascal and
- A printing filter that gives the user the ability to manipulate
a document in various ways (e.g. change paper size, print only
selected pages or ranges, print duplex, rearrange pages, etc.),
to preview a document, and to send it to a file, a printer, mail,
fax systems, or other programs.
PriMa requires documents in PostScript
format, but if they aren't it can use the
MagicFilter package to convert a
file to PostScript.
PriMa is basically an interface built around the
psutils package, and as such has all
A source code distribution of PriMa is available. It
can be compiled and used on many UNIX flavors including Linux.
Compilation requires the XForms
library at version 0.86 or newer.
It is documented in a README file available in both ASCII
and PostScript formats.
- printing utilities
- A wide variety of software for enabling and handling
the performance of various printing tasks
is available for Linux platforms.
Useful sites include:
The available packages include
- APSL, a common printing API for GNU/Linux and
other UNIX systems
- a2ps, a filter for converting nearly any format
to PostScript for printing;
- CEPS, a printing system designed for medium
to large networks;
- CUPS, an implementation of the
- GNU enscript, a filter for converting
text files into PostScript for printing;
- FLpr, a script that unifies the usage of
several other printing-related programs;
- LPRng, an implementation of an
LPD-protocol based print spooler;
- nenscript, a filter for converting
text files into PostScript for printing;
- pdq, a straightforward and flexible print;
- PPR, a print spooler centered on
- PriMa, a printing filter;
- pup, a GUI utility for maintaining printers
under Linux; and
- rlpr, a network printing utility.
- The Portable RT[S]P Internet Streaming
Server is, as the name indicates, a portable streaming Internet
server based on Apple's Darwin Streaming Server.
Source code and binary versions are available for Linux platforms.
- A PGP-aware replacement for the standard Sun mailtool
program with a similar user interface and automagick support
for PGP-signing and PGP-encryption.
Privtool displays a list of messages along with flags indicating
whether they are signed or encrypted and if they have had their
signatures verified or have been decrypted.
Double-clicking on a message will automatically decrypt and
display it (and will also check the signature if necessary).
When composing or replying to a message, the resulting message
can be digitally signed and/or encrypted. It can also use
anonymous remailer to send the message through
one or more remailers.
The source code for Privtool is available at a European
site which bypasses U.S. cryptography export regulations.
It is known to work on Sun SunOS and Solaris, FreeBSD, and
Linux Intel platforms.
It is documented on the site as well as in documents in the
- The Programmer's Reusable Library is a
family of compatible
software libraries intended to promote software reuse. It consists
of a layered set of seven libraries with a strong emphasis on
computer graphics. These libraries provide a
programming language primitive data types (PROGRLANG),
graphical device drivers (DEVICE),
low-level graphics (GRAPHICS),
graphical function plotting (PLOT), graphical surface
and graphical cartographic map plotting (MAP).
The seven libraries provide a wide array of capabilities.
- The POSIX library is a general purpose Fortran-callable
library which provides application programs with access
to POSIX functions.
- The PROGRLANG library is intended to provide useful operations
on Fortran primitive data types as a supplement to the standard
set of Fortran intrinsic functions.
- The DEVICE library provides a standardized interface to graphics
output devices in support of the GRAPHICS library. Currently
(4/97) supported devices include DEC LN03, HP LaserJet,
PostScript (Level I and II), Tektronix (4014, 4115, 4107, and 4510),
X terminal, and Vector Save file format.
- The GRAPHICS library provides fundamental 2-D graphics
capabilities such as line drawing and graphical text generation.
It also supports graphics attributes such as color, line style,
line thickness, character shading, and area blanking.
- The PLOT library supports the production of 2-D and 3-D
function plots. Supported plot types include: 2-D linear, log,
log-linear, and polar plots; 2-D bar and pie charts; and 3-D
linear and spherical plots.
- The SURFACE library supports the production of 2-D and
3-D surface plots. Supported plot types are: 2-D surface line
contour and color-shaded contour plots; 3-D surface mesh
wireframe (with and without hidden line removal); 3-D
surface line contour plots; and 3-D color-shaded contour plots.
- The MAP library supports the production of 2-D cartographic
projection plots. It currently supports Lambert Equal Area and
Cylindrical Equidistant projections and provides two cartographic
data bases of the Earth, i.e. low and high resolution databases.
The PRL is available
for several platforms and as of 12/15/95 was freely available in
binary form for Linux platforms. A user's manual and reference
guide in PostScript format are included in the
- The Prospero Resource Manager enables users
to run sequential or parallel applications on a network of
workstations. Sequential jobs are offloaded to lightly loaded
processors while parallel jobs use some or all of the processor
collection to achieve speedups in execution time.
The parallel applications are based on the message passing
model and are linked with a communication library which provides
routines for sending and receiving tagged messages, broadcasting,
and global synchronization.
The interfaces available are the CM-5 CMMD library and
a PVM interface, both of which allow the
development of applications without having to modify any source
code for use with PRM.
The resource allocation functions of PRM are distributed across
system managers which control access to a collection of processing
resources and allocates them to jobs as requested by job managers;
job managers which acquire processing nodes from system managers
and initiate tasks on these nodes through node managers; and
node managers which initiate and monitor tasks on the nodes on
which they're running.
The features of PRM include:
- utility programs to checking the status of running jobs, query the
status of a system manager and the nodes it manages, and to gracefully
shut down a PRM system;
- the use of an access control list (ACL) to determine whether
the host requesting resources is authorized;
- library routines for standard I/O tasks and for task creation and
- the checkpoint and migration of tasks to other nodes when the current
node makes itself unavailable; and
- application debugging.
A source code distribution of PRM is available. It is written
in C and should compile and install on many generic UNIX
platforms on which PVM is installed.
The documentation includes a user's manual and several
technical papers, all available in
- The Precipitation-Runoff Modeling System
is a modularly-designed, deterministic, distributed-parameter
modeling system developed to evaluate the impacts of various
combinations of precipitation, climate, and land use on streamflow,
sediment yields, and general basin hydrology.
Basin response to normal and extreme rainfall and snowmelt can
be simulated to evaluate changes in water-balance relationships,
flow regimes, flood peaks and volumes, soil-water relationships,
sediment yields, and ground-water recharge.
Parameter optimization and sensitivity analysis capabilities are
provided to fit selected model paramters and evaluate their
individual and joint effects on model output.
PRMS divides a watershed into subunits based on basin characteristics
such as slope, aspect, elevation, vegetation type, soil type,
land use, and precipitation distribution.
Two levels of partitioning are available, with the first dividing
the basin into homogeneous response units (HRU) based on basin
characteristics. The sum of responses for all HRUs, weighted on
a unit area basis, produces the daily system response and streamflow
for a basin. The second partitioning level is used for storm
hydrograph simulation. In this level the watershed in conceptualized
as a series of interconnected flow planes and channel segments.
Surface runoff is routed over the flow planes and into the channel
segments, and channel flow is routed through the watershed channel
system. An HRU can be either the equivalent of a flow plane or
can be separated into a number of flow planes.
A source code distribution of PRMS for UNIX platforms is
The primary documentation is contained within
Leavesley et al. (1983).
This is part of the USGS
Water Resources Applications Software
- The Parallel Random Number Generator library
provides several pseudo-random number generators via a common interface
on any shared or distributed memory parallel architecture.
Common routines are specified to initialize the generators with
appropriate seeds on each processor and to generate uniform, normal,
Poisson or exponential distributed random vectors.
Lagged Fibonacci, generalized shift register, and multiplicative
linear congruential generators are implemented with almost arbitrary
specifications for lags, multipliers, moduli, etc.
Also included in the package are a set of support routines, test
routines, and example programs parallelized using
the MPI library.
The library is documented via a user's manual in PostScript format.
- A powerful set of tools which enable the automatic processing
of mail either as it is received or after it is already in
a message folder. The package consists of three programs:
procmail, formail, and lockfile.
The features of the procmail program include:
- small size, easy installation and simple to maintain and configure;
- event driven invokation and no use of temporary files;
- use of standard egrep regular expressions;
- low use of system resources;
- easy yes-no decisions on where the mail should go;
- neural net type weighted scoring of mail messages;
- reliably filtering, delivering, and forwarding mail;
- a reliable hook for starting any programs or shell scripts
upon mail arrival;
- good performance under bad system conditions;
- absolutely undeliverable mail is bounded back to the sender;
- reliable mailbox locking across NFS;
- support for four mailfolder standards;
- provision of a mail log file chock full of gory details;
- display of a wide variety of
diagnostic and error message (using the mail log);
- no limits on line length, mail length, or the use of any
- secure system mailbox handling;
- provision for controlled execution of programs and scripts
from the alias file;
- allowing for shifting of system mailboxes into
- clock skew immunity; and
- works with sendmail, ZMailer, smail, MMDF, and mailsurr.
The formail program features include
The lockfile program provides NFS-secure lockfiles to shell
script programmers and gives normal users to ability to lock
their system mailbox regardless of the permissions on the
- generation of auto-reply headers;
- conversion of mail into standard mailbox format (for processing
with a standard mail program);
- splitting up mailboxes, digests, and saved articles
into individual messages;
- simple header munging/extraction;
- extraction of messages from mailboxes; and
- recognition of duplicate messages.
The source code for the procmail package, written in C, is
available on can be installed on most generic UNIX
platforms (since the code is POSIX, ANSI C and K&R conforming).
The documentation is contained within a veritable ocean
of man pages.
- An extensible email filtering package developed to circumvent the
limitations and arcane syntax of procmail
(although it still requires and uses the latter).
The packages includes several filters including those
for addresses, the domain of the sender, the login of the sender,
phrases in the message content, bogus domains, and phrases in the subject
line. A vacation filter is also included.
A source code distribution of this Perl
package is available.
- A collection of procmail scripts
for building an advanced mail handling system.
The scripts include:
- ackmail.rc, a set of recipes for performing auto-acknowledgement
of incoming mail;
- commands.help, a file of information sent in response to
mail requests for information;
- commands.rc, a set of recipes which recognize commands in
the Subject header and perform them;
- dupcheck.rc, a recipe file which removes duplicate mail;
- get-from.rc, a recipe file which extracts the best address from
the various originating address fields;
- guess-mua.rc, a recipe file which attempts to guess the current
- headers.rc, which defines some variables which can be used for
matching against headers; and
- unread-mh.rc, a recipe file which attempts to compute how many
unread messages there are for an MH user.
- This package consists of a library which parses the
textual /proc filesystem and a suite of utilities
which uses the library.
The utilities are:
- ps, which gives a snapshot of the current system processes;
- uptime, which tells how long the system's been running;
- w, which displays information about the users on the
machine and their processes;
- free, which displays the total amount of free and used physical
and swap memory in the system;
- pstree, which shows running processes as a tree;
- killall, which sends a signal to all processes running
any of the specified commands;
- fuser, which displays the PIDs of processes using specified
files or filesystems;
- top, which displays the top CPU processes;
- tload, which prints a graph of the current system load average;
- vmstat, which reports information about processes, memory, paging,
block I/O, traps, and CPU activity;
- sessreg, a program for managing utmp/wtmp entries for xdm sessions;
- psupdate, which updates the /etc/psdatabase file to correspond
to the current kernel image system map file;
- watch, which watches a program as it changes;
- skill, which sends the terminate signal to a set of processes;
- snice, which alters the scheduling priority of selected processes;
- xload, which displays a periodically updated histogram of the
system load average;
- XConsole, which displays kernel messages in an X Window;
- xcpustate, which displays bars showing the percentage of time the
CPU spends in different states;
- psdatabase; and
The procps utilities are available in source code as well as
in executable form, with both included in the distribution.
Each program is documented in a man page.
- The Programmer's Runtime Optimized Fast
Interval Library is a C++
class library supporting the most commonly needed
interval arithmetic and
real operations. The supported data types are INT, REAL,
INTERVAL, vectors and matrices of these types, and complex
PROFIL is based in BIAS (Basic Interval Arithmetic Subroutines),
which aims to do for interval arithmetic what
BLAS has done for non-interval arithmetic, i.e.
provide an interface for basic vector and matrix operations with
specific and fast implementations for various architectures.
The difference between the two is that all interval operations
of PROFIL are independent of the internal representation and
implementation of the interval types.
The PROFIL/BIAS library includes various scalar interval,
vector, integer vector, matrix, interval matrix, and integer
It also contains a large selection of standard functions, e.g.
trigonometric and log functions, absolute value, etc., as well
as utility functions for finding matrix inverses, transposes,
identities as well as some interval vector functions.
There are also linear system solvers which compute the enclosures
of solution sets.
There is a procedure for using Fortran library functions with
the library, and multiple precision arithmetic is also possible.
An extension package called PROFEXT is available which
contains miscellansous functions, test matrices,
subroutines for local minimization, general linear singly
linked lists, automatic differentiation subroutines, sample
programs, and instructions on how to adapt the library to
Compilation of PROFIL/BIAS on UNIX systems requires the use of
the dmake utility.
The source code is configured to compile and installed on
several platforms, including Linux Intel.
An extensive user's and reference guide is available in
- A least squares fitting program that fits one protein structure
to another, allowing as much flexibility as possible.
- An FTP daemon for UNIX systems that is designed
to be secure and highly configurable.
The features of ProFTPD include:
A source code distribution is available.
- a single main configuration file with directives and directive groups
similar to those in Apache;
- a per directory .ftpaccess configuration;
- configurable multiple virtual FTP servers and anonymous FTP services;
- running either as a stand-alone server or from inetd;
- no required directory structure, system binaries, or other system
files in FTP root directories;
- no insecure SITE EXEC command, i.e. no external programs are ever
- hidden directories or files;
- runs as a configurable non-privileged user in stand-alone mode;
- logging and UTMP/WTMP support; and
- shadow password suite support.
- An inductive logic programming (ILP) system which combines
inverse entailment with general-to-specific search through a
Inverse entailment is used with mode declarations to derive
the most-specific clause within the mode language which entails
a given example. This clause is used to guide a refinement-graph
The Progol search is efficient and has a provable guarantee
of returning a solution having the maximum compression in the
search-space. It does this by performing an admissible A*-like
search guided by compression over clauses which subsume the most
It deals with noisy data by using the compression measure to trade-off
the description of errors against the hypothesis description length,
and allows arbitrary Prolog programs as
background knowledge and arbitrarily define clauses as examples.
Progol is available in a source code distribution.
It is written in ANSI C and can be compiled and used on
most UNIX platforms.
It is documented in a user's manual available in
See Muggleton (1995).
- A Perl script implementing a small extension
to HTML that allows programmers to write
more sophisticated Web pages.
The main idea is that the programmer defines how a certain
tag is rendered as well as the language in which the script, program,
or external program is written.
A source code distribution is available.
- programming/development environments
- Programming environments available for Linux include:
Editors with extensive programmer-friendly features (e.g. syntax
highlighting, compilation from within, etc.) include:
- Basis, a development environment for
creating Fortran programs;
- Chicory, an IDE for
- Code Crusader, built using the
- FarGo, a Java-based
environment for developing mobile-component based distributed applications;
- Free Builder, an IDE for
- gIDE, a GTK-based IDE
- GRASP, a environment for the graphical
representation of algorithms, structures and processes;
- Jipe, an IDE for
- KDevelop, a development environment
for UNIX/X11 platforms;
- Moonshine, an application development
environment with modular support for many languages;
- Paradigm Visual Make, and IDE
written using Tcl/Tk;
- RHIDE, an IDE for DJGPP;
- Source Navigator, an IDE developed
by Cygnus for C, Fortran, C++, Java with a limited free version;
- TCL Developer Studio, an
environment for developing Tcl applications;
- WipeOut, an IDE supporting C, C++, Java,
Eiffel and Fortran (with a limited freely available version); and
- XWPE, a programming environment for UNIX
systems with a curses-like interface.
- programming language
- Hundreds of programming languages have been at least theoretically
proposed since the advent of the use of computers, and compilers
have been created for many of these.
Over a hundred of these compilers are currently available for
use on Linux platforms.
A compiler is a program which usually translates
source code written in a high level language (e.g. C, C++, Fortran)
into the instruction set of a specific computer CPU.
Programming languages have been categorized in more than one way.
From a functional standpoint, they are often split into imperative
and declarative languages.
An imperative program consists of sequences of commands that
update variables held in storage, i.e. the program has a state that
is altered as the program progresses. Imperative languages have
been around the longest and include such oldies as
Fortran, COBOL and
C. A more recent phenomena are non-imperative
or declarative languages. These differ from imperative languages
in that they are concerned more with expressing what a program does
than how it does it, i.e. unlike imperative languages there is no
implicit state that can be modified by assignment statements or other
Declarative languages are usually split into two further
categories called functional and logic languages.
Another categorization scheme splits languages into those that
are object-oriented (OO) and those that aren't. Sometimes a further
distinction is made among the OO languages between those that support
some OO features and those that are more or less completely OO.
Another distinction is made between serial and parallel languages,
with the former running on machines with a single CPU and the latter
on those with two or more CPUs.
Yet another distinction is made between compiled and interpreted
languages, although this is more a matter of how the language is
going to be used rather than its inherent features, i.e. most
languages can be used with either a compiler or an interpreter and
many have both.
Embedded languages are usually smaller versions of regular
languages used in processors embedded in some sort of machine
rather than a full-blow general purpose computer.
Scripting languages are usually identified as those used for the
rapid development of prototype software, and as such they are
usually interpreted rather than compiled.
The programming language categories for which I've bothered to
establish separate entries include:
Useful books on the topic include:
Friedman et al. (1992),
Mitchell (1996a), and
Interesting review sites include:
Implementations of programming languages (interpreters, compilers,
translators, preprocessors, or some combination thereof) include:
Glasgow Haskell Compiler,
- A cartographic projection program designed as a standard UNIX
filter utility to be employed with other programs in the generation
of maps and charts as well as map digitizing applications.
The PROJ package consists of three programs: proj/invproj, which
performs forward and inverse transformation of cartographic data
to or from cartesian data with a wide range of selectable projection
functions; geod/invgeod, which performs geodesic (Great Circle)
computations for determining latitude, longitude and back azimuth
of a terminus point given an initial point latitude, longitude,
azimuth and distance (direct) or the forward and back azimuths
and the distance between the initial and terminus point latitudes
and longitudes (inverse); and
nad2nad, a North American Datum conversion filter to convert between
the Datum of 1927 (NAD27) and that of 1983 (and which can also process
State Plane Coordinate System (SPCS) and Universal Transverse
Mercator (UTM) grid data as well as geographic data for both
input and output).
The projections included in the first release were:
- cylindrical projections,
e.g. Mercator, Transverse Mercator, Universal Transverse Mercator,
Oblique Mercator, Central Cylindrical, Transverse Central
Cylindrical, Miller, Lambert Cylindrical Equal Area, Gall
(Stereographic), Transverse Cylindrical Equal Area, Equidistant
Cylindrical, and Cassini;
- pseudocylindrical projections,
e.g. Sinusoidal, Mollweide, Robinson, Eckert I through VI,
Goode Homolosine, Hatano Asymmetrical Equal-Area, Loximuthal,
McBryde-Thomas Flat-Polar Parabolic (or Quartic or Sinusoidal),
Putnins P, Quartic Authalic, Winkel I, Boggs Eumorphic,
Collignon, Denoyer Semi-Elliptical, and Craster Parabolic;
- conic projections,
e.g. Lambert Conformal Conic, Equidistant
Conic, Perspective Conic, Albers Equal Area, Lambert Equal
Area, Bipolar Oblique Conic Conformal, Polyconic (American),
Rectangular Polyconic, and Bonne;
- azimuthal projections,
e.g. Stereographic, Universal Polar Stereographic,
Orthographic, Airy, Near-Sided Perspective, Lambert Azimuthal
Equal Area, Azimuthal Equidistant, Hammer, Wagner VII,
Aitoff, and Winkel Tripel; and
- miscellaneous projections,
e.g. August Epicycloidal, Bacon Globular, Nicolosi Globular, Fournier
Globular I, Apian Globular I, Eisenlohr, Ortelius Oval,
Van der Grinten I through IV, and Lagrange.
More projections were added in a second release of the
A third release added yet more projections including:
- Two Point Equidistant (Doubly Equidistant),
- New Zealand Map Grid,
- LANDSAT grid,
- 50 United States Modified Stereographic,
- Alaska Modified Stereographic,
- Lee Oblated Stereographic,
- Miller Oblated Stereographic,
- Mercator (Wright),
- Lambert Conformal Conic (Conical Orthomorphic), and
- Oblique Mercator (Rectified Skew Orthomorphic).
- pseudocylindrical projections,
e.g. Generalized Sinusoidal, Urmaev Flat-Polar
Sinusoidal Series, Eckert V, Wager II through VI, Foucaut Sinusoidal,
Hatano, Kavraisky VII, Putnins P through P, Craster,
MacBryde-Thomas Flat-Polar Parabolic (and Sine and Quartic),
Sine-Tangent Series, Nell-Hammer, Robinson, Denoyer, Fahey,
Ginsburg VIII, and the Urmaev V Series; and
- miscellaneous projections,
e.g. Aitoff, Hammer-Aitoff, Eckert-Greifendorff,
Larrivée, and Laskowski.
The package contains the source code, written in ANSI C for
portability for all three programs. The documentation is
contained within three technical reports available in
PostScript format (which contain some very nice graphics
for most of the projections). This package can be used as
a standalone package as input for some other program or with
the MAPGEN front-end package.
- The PROgramming in LOGic language is an example of
a logic programming language.
It was originally designed for artificial intelligence (AI)
applications and is based on the notion of defining objects
and inferential relationships among classes of those objects.
Its theoretical foundations can be found in propositional calculus.
It was developed in the early 1970s by Philippe Roussel of the
Artificial Intelligence Group at the University of Marseille in
France, with the first interpreter implemented in 1972.
PROLOG is extensively used in several
application areas including theorem proving and
problem solving, mathematical logic, natural language understanding,
expert systems and knowledge representation, although its limitations
have kept it from being used in such areas as numerical programming, data
processing and systems programming.
Prolog implementations include:
Clocksin and Mellish (1984),
Konigsberger and deBruyn (1990),
Pereira and Shieber (1987) and
- A highly parallel multigrid solver for the set of linear equations
that arise from 3-D finite element discretizations of PDEs.
Prometheus uses multigrid techniques to precondition Krylov subspace
methods to solve for x in nonsingular matrix equations of the
The solver library implements two fully parallelized, unstructured
<LI>a method that automatically constructs the coarse grids using
an algorithm based on maximal independent sets and delaunay tesselation,
and the restriction operators using linear finite element shape functions
on the coarse grid;
<LI>an algebraic multigrid method called smooth aggregation.
It is built on top of
- Prometheus Project
- An umbrella project for a group of individual projects related to
MySQL to develop active content Web sites.
- Apache Compile Kit
- A Perl script for automatically compiling
PHP, Apache and
various other modules, normally a daunting task.
- Mysql Clustering Toolkit
- A package for clustering a set of MySQL servers
for providing high availability and/or distributed data.
A master server is a write server whose writes are logged by a script
and placed into a log database.
Other individual servers read from the log database via a pull method
that requires a small table on the local host that stores the IDs of
the SQL it ran against the database. Such a methodology can be used
as a multi-mastered or multi-write solution.
- Prometheus Application Framework
- A framework for building active content web sites.
This is not yet releases as of 1/18/00 although there are many
screenshots of the development version available.
- An API of objects, functions and defines for designing active content sites
with minimal effort. The functionality includes:
- AutoLoad, loads only the needed classes and their dependencies;
- Sessions, stores cascaded state information;
- Database Independence, a framework for a database independence
- BenchMarking, an object for benchmarking code segments;
- UserAuth, an authentication class that takes pluggable
- UserDomain, a virtual domain for users within a website;
- WebClient, identifies browser capabilities and features;
- Unix Utilities, reads UNIX password files;
- FileSize, obtains a file size and formats it using the
- PageNavigator, for creating multiple page navigation;
- UrlObject, for creating URLs;
- MimeObject, for figuring out MIME
- Mail, for reading and sending mail via both
IMAP and local sendmail; and
- Templates, for parsing simple templates.
- A modularized GTK
MUA written in
The features include:
- full MBOX support (import and export);
- QMaildir support;
- read-only HTML mail;
- support for GtkHTML and
- a built-in help browser;
- a smart address book that autocompletes addresses;
- message colorization based on quote symbols and their levels;
- spelling and autospelling;
- MIME support including inbound and outbound
- working hyperlinks within messages;
- use of the Perl DBI interface for
- non-blocking mail transfers;
- multiple POP3 account support;
- filters for mail lists including a new message scoring system;
- multiple signatures;
- autoset reply addresses based on account used to DL message;
- schedulable message transfers;
- an outbox for storing unsent outbound messages;
- context sensitive menus;
- sent items and drafts folders;
- multiple message selection; and
- multiple folders.
- A multi-mission X-ray analysis software system designed to
run under the IRAF system.
PROS is designed to handled the data screening and masking needed
due to features of X-ray data such as scarcity, low signal-to-noise
ratio, and large gaps in exposure time.
It includes routines for spatial, spectral, timing, and data I/O and
conversion as well as plotting applications and general algorithms
for performing arithmetic operations on image data.
The package consists of functional groups called tasks which are in
turn grouped into packages. The major packages are:
- xdataio, for converting data to and from
- xplot, plotting routines for X-ray data;
- ximages, additions to the IRAF images package;
- xspatial, for X-ray spatial analysis;
- xspectral, for X-ray spectral analysis; and
- xtiming, for X-ray timing analysis.
The tasks contained in the PROS analysis packages include:
- display and xdisplay, for producing TV displays of data;
- imcontour and skygrid, for calculating and graphing
iso-intensity areas of images and displaying them on a sky grid;
- coordinates, for working with the World Coordinate System (WCS);
- sgraph, for graphing all non-image output files;
- detect, for performing maximum likelihood source detection
on data with Poisson statistics;
- imcalc, immodel and imsmooth, for generating
complex point response function model images that can be convolved
- imcnts, for extracting background subtracted counts from
- timcor, for performing time corrections;
- ltcurv, fft, period, fold, qpphase, and
phase, for examining periodic data;
- qpspec, for extract a background corrected spectrum;
- xflux, for calculating fluxes for any object; and
- a flexible spectral model specification langauge allowing
multi-component model fitting.
A source code distribution of PROS is available as are binaries for
selected platforms including Linux Intel.
The package is written mostly in C.
A user's guide is available in the usual formats.
- A interactive system for enabling
domain experts to build knowledge-based systems
by creating and modifying reusable ontologies and problem solving
methods. Protege generates domain-specific knowledge acquisition
tools and applications from the developed ontologies.
It is built as a system of three layers, with each communicating with
the layers beneath via well-defined APIs.
These layers are:
- a widget layer that is a user-interface component allowing a small
part of the knowledge base to be viewed and edited;
- a control layer that handles standard actions (e.g. menu items)
and the connections between widgets and the underlying knowledge base; and
- a wrapper around the knowledge base server that is a set of
model interfaces specifying what must be implemented.
- An exectutable, high-level, architecture-independent parallel
programming notation in which sophisticated parallel algorithms
free of complex low-level architecture-specific details can be
developed and evaluated.
This is a rapid prototyping system which permits the exploration
of a large and complex space of alternatives.
Proteus represents a refinement based development methodology
where the refinement of a program consists of modifying it to
reflect restrictions in the use of concurrency constructs, with
the restriction expressing the adaptation of a high-level design
to constructs efficiently supported on a specific architecture.
Programs which are suitably refined in their use of the Proteus
notation can be automatically translated to efficient parallel
programs in low-level architecture-specific notations, and can
then be run directly on the targeted architecture.
The Proteus environment consists of several components:
Proteus currently (5/97) only works with a CVL library
implementation for MasPar computers, but an implementation which
will run on top of PVM is being developed.
- a program repository organizes different versions of Proteus
programs and the low-level generated codes using either CVS
- a program modification system creates new versions of programs
via either manual editing to change the functionality or restriction
of a program, or by the automatic generation of a low-level
program from a restricted Proteus program;
- a program execution system consists of a Proteus interpreter
including run-time monitoring and analysis functions as well as
an interface to external modules in the form of existing applications
or those generated by the translation of Proteus programs; and
- a module interconnection facility (MIF) is a socket-based
facility managed by the interpreter to permit Proteus programs
to communicate with concurrently executing external applications.
A sequential Proteus interpreter is currently available in source
It should compile and run on many UNIX platforms.
The documentation includes a language manual available in
- A style-independent
system built on top of LaTeX.
ProTeX is extensible, language independent, and produces
multiple output files.
- Various computer and network protocols including:
- ACAP, the Application Configuration Access
Protocol is designed to support remote storage and access of program
option, configuration and preference information (2244);
- AgentX, a protocol for communication between
master agents and subagents within a standardized framework for extensible
SNMP agents (2257);
- ANEP, the Active Network Encapsulation
- AODV, the Ad Hoc On-Demand Vector routing
protocol is for mobile nodes in an ad hoc network;
- ARP, the Address Resolution Protocol is for
converting IP addresses into Ethernet addresses;
- ATM, Asynchronous Transfer Mode
- BGP, the Border Gateway Protocol is an
inter-Autonomous System routing protocol whose primary function is to
exchange network reachability information with other BGP systems (1771);
- CAMAC, a standard electronic interface system
protocol generally used for data acquisition;
- CAN, a protocol for a serial bus system with
- CBRP, the Client Based Routing Protocol is one
designed for use in mobile ad hoc networks;
- CMIP, the Common Management Information Protocol
- DeviceNet, a networking standard for
industrial automation applications;
- DHCP, the Dynamic Host Control Protocol provides
a framework for passing configuration information to hosts on a TCP/IP
- DICT, the Dictionary Server Protocol is a TCP
transaction-based query/response protocol allowing a client to access
dictionary definitions from a set of natural language dictionary
- DRP, the Distribution and Replication Protocol is
for improving the optimizing the performance of the Web;
- DSDV, the Destination Sequenced Distance Vector is
a multi-hop ad hoc network routing protocol
- DSR, the Dynamic Source Routing is a
multi-hop ad hoc network routing protocol
- DVMRP, the Distance Vector Multicast Routing
- EGP, the External Gateway Protocol enables
networks to exchange information on how to reach other networks;
- FDDI, the Fiber Distributed Data Interface
- fibre channel, a set of protocols for
a 1 gigabit per second data transfer interface technology;
- FireWire, a type of high speed serial
bus protocol for devices requiring significant bandwidth;
- Frame Relay
- FTP, the File Transfer Protocol
- GSMP, the General Switch Management Protocol is
a general purpose protocol to control an ATM
- HCP, the Human Communications Protocol is for
handling any form of communications a human might want to use over
a computer network;
- HDLC, the High-Level Data Link Control protocol
concerns transmitting data at a set flow rate across a network;
- HTCPCP, the Hyper Text Coffee Pot Control
Protocol is for controlling, monitoring and diagnosing coffee pots (2324);
- HTTP, the HyperText Transport Protocol
- ICMP, the Internet Control Message Protocol
- ICP, the Internet Cache Protocol
- IGMP, the Internet Group Management Protocol
is used by IP hosts to report their multicast group memberships to
- IGRP, the Interior Gateway Routing Protocol
for routing within an autonomous system;
- IKE, the Internet Key Exchange protocol is for
negotiating and providing authenticated keying material for security
associations in a protected manner;
- IMAP, the Internet Message Access Protocol specifies
a method for accessing email that is kept on a mail server;
- IOTP, the Internet Open Trading Protocol
- IP, the Internet Protocol is the network protocol
for the Internet protocol suite;
- IPP, the Internet Printing Protocol;
- IPSec, Internet Procol Security is the security
standard for Internet communications;
- IPv6, the next generation IP
- IRDP, the ICMP Router Discovery Protocol
- ISAKMP, the Internet Security Association
and Key Management Protocol;
- ISDN, the Integrated Services Digital
- ISL, the InterSwitch Link protocol is for
connecting VLAN-capable Ethernet switches;
- Kerberos, a network identification protocol
- LDAP, the Lightweight Directory Access Protocol is
designed to provide access to the X.500 Directory and targeted a simple
management applications and browser applications that provide simple read
or write interactive access to X.500 (2251);
- LDP, the Label Distribution Protocol establishes
how Label Switched Routers established Label Switched Paths through a
network by mapping network layer routing information directly to data-link
layer switched paths;
- L2TP, the Layer 2 Tunneling Protocol is a method
for encapsulating PPP through various media;
- MathML, Mathematical Markup Language provides a
method for including math expressions on Web pages;
- MGCP, the Media Gateway Control Protocol is for
controlling telephony gateways via call agents;
- MIME, the Multipurpose Internet Mail Extensions
- MMS, the Manufacturing Message Specification
is an OSI application layer protocol for the
remote control and monitoring of industrial devices;
- Mobile IP, a protocol for mobile computer
users who wish to connect to the Internet and maintain that connection
while moving from place to place;
- MOSPF, the Multicast Open Shortest Path First
- MSIX, the Metered Service Information Exchange is
a protocol designed to enable ISPs to effectively meter usage;
- NDMP, the Network Data Management Protocol
- NHRP, the NBMA Next Hop Resolution Protocol
is used by a host or router connected to a NBMA subnetwork to determine
the internetworking layer address and NBMA subnetwork addresses of the
``NBMA next hop'' towards a destination station (2332);
- NFS, the Network File System;
- NLSP, the Network Layer Security Protocol;
- NNTP, the Network News Transport Protocol
- NPMP, the Network Peripheral Management Protocol
- NTP, the Network Time Protocol
- OKBC, the Open Knowledge Base Connectivity
protocol is for accessing knowledge bases stored in knowledge
- OSI, the Open Systems Interconnection protocol
is a seven layer model for network communications;
- OSPF, the Open Shortest Path First
TCP/IP routing protocol distributes, based on
link-state or SPF technology, information between routers belonging to
a single Autonomous System (2328);
- OTP, the One-Time Password authentication system
provides authentication for system access and other applications requiring
authentication that is secure against passive attacks based on replaying
captured reusable passwords (2243);
- PGM, the Pragmatic General
Multicast protocol is a reliable
multicast transport protocol for applications requiring ordered,
duplicate-free, multicast data delivery from multiple sources to
- PGML, a 2-D scalable graphics language;
- PIM, the Protocl Independent Multicast, for
establishing multicast connections across wide-area internets where groups
are sparsely represented and bandwidth not plentiful;
- POP, the Post Office Protocol is a
store-and-forward mail deliver protocol;
- PPP , the Point-to-Point Protocol
- RADIUS, the Remote Authentication Dial In User
Service protocol provides an open and scalable client/server security
system for dial-up access;
- RIP, the Routing Information Protocol is one
for exchanging routing information among gateways and other hosts;
- RPC, the Remote Procedure Call
- RSVP, the ReSerVation Protocol is part of a
larger effort to enhance the Internet architecture with support for
quality of service flows;
- RTP, the Real-time Transport Protocol provides
end-to-end network transport functions for applications transmitting
- RTSP, the Real Time Streaming Protocol is an
application-level protocol for controlling the delivery of data with
real-time properties (2326);
- SCSP, the Server Cache Synchronization Protocol
attempts to solve the generalized cache synchronization/cache replication
problem for distributed protocol entities (2334);
- SDP, the Session Description Protocol is intended
for describing multimedia sessions for the purposes of session announcement,
invitation, and other forms of session initiation (2327);
- S-HTTP, the Secure HTTP provides a secure
message-oriented communications protocol;
- SIP, the Session Information Protocol is a signaling
protocol for Internet conferencing and telephony;
- SKIP, Simple Key management for Internet Protocols
secures the network at the IP package level;
- SLIP, the Serial Line Internet Protocol
- SNQP, the Simple Nomenclator Query Protocol
is for querying servers that search collections of data repositories (2259);
- SOCKS, a networking proxy protocol that enables
hosts on one side of a SOCKS server to gain full access to those on the
other side without requiring direct IP reachability by authenticating
and authorizing requests, establishing a proxy connection, and relaying
- sRGB, a standard default color space for
- SSL, the Secure Sockets Layer is a security protocol
implemented on top of TCP/IP;
- SVG, Scalable Vector Graphics is a standard for
raster graphics on the Web;
- TCP, the Transport Control Protocol is the major
transport protocol in the Internet protocol suite;
- TFTP, the Trivial File Transfer Protocol
- TLS, Transport Layer Security is a protocol for
providing communications privacy over the Internet;
- TNPP, the Telocator Network Paging Protocol
defines a mechanism for moving information between paging terminals;
- TORA, the Temporally-Ordered Routing Algorithm is
a network routing protocol for use with mobile wireless networks;
- UDP, the User Datagram Protocol
- USB, the Universal Serial Bus is a low speed
serial bus protocol both hot-pluggable and plug-and-play;
- UCM, Use Case Maps is a notation used to
describe the behavior of complex and dynamic systems;
- VIA, the Virtual Interface Architecture
defines a standard architecture for communication within clusters of
- VML, the Vector Markup Language defines a format
for encoding vector information and markup for displaying that information;
- VNET, the Virtual NETwork protocol is a virtual
protocol that manages multiple physical network protocols
- VRRP, the Virtual Router Redundancy Protocol
specifies an election protocol for dynamically assigning responsibility
for a virtual router to one of the VRRP routers on a LAN (2338);
- VSAP, the Virtual Socket Association Protocol
- WAIS, the Wide Area Information Server
- WAP, the Wireless Application Protocol is a global
wireless protocol specification;
- WIDL, the Web Interface Definition Language defines
APIs to Web data and sources;
- WML, the Wireless Markup Language
is HTML designed
for use with cellular devices with lower bandwidths;
- XMODEM, a protocol for transferring files over
- XTP, the Xpress Transport Protocol is a transport
layer protocol for providing a wide range of communication services via
orthogonal transport mechanisms;
- YMODEM, a protocol for transferring files over
- ZMODEM, a protocol for transferring files over
- ZRP, the Zone Routing Protocol is a hybrid
protocol suitable for a wide range of mobile ad-hoc networks.
- A package containing three daemons for logging
the TCP, UDP and
ICMP packets arriving at a machine. It also
logs IP options and can evade IP
The programs in the package are:
A source code distribution is available. The programs are documented
in man pages.
- KillLoggers, a script for killing all the loggers;
- LaunchLoggers, a script for starting all the loggers;
- ipretlog, interprets raw Protolog output files and outputs
a readable report;
- plogicmp, the ICMP packet logger;
- plogtcp, the TCP packet logger; and
- plogudp, the UDP packer logger.
- An Open Source
Java application server for
building database-driven Web sites.
The documentation is currently (7/99) in javadoc format.
- A collection of globally-installed shared Makefiles for assisting
in project development. Prototype Makefiles also contains Makefile
templates that can be copied into project directories using a simple
script. The shared Makefiles contain the rules for building a project,
clean it and making dependencies, and all the other tedious tasks
involved in such things. The Makefile templates contain the data
that is specific to each project. Maintenance and extension are
easier since this separation avoids duplication of code in Makefiles.
- The free PROfessional audio Tools for LinUX is a project
to create a definitive solution for audio professionals who need a suite
of powerful and practical software for daily work.
It is being patterned on the expensive ProTools commercial software
suite, although it will not require special hardware but rather work
through the /dev/dsp(n) interfaces via
- A pair of Perl scripts for combining and
extracting a PostScript cover page and an arbitrary PostScript
document. These utilities use the Adobe Document Structuring
Conventions to create a composite document understandable
to printers and previewers.
- A set of Matlab scripts for obtaining
Power Spectral Density estimates from time
series using the maximum entropy and Welch overlapped
The programs include:
- MESA, calculates a maximum entropy spectrum;
- WILHIL, calculates the Wilson-Hilferty approximation to
the chi-squared distribution;
- WOSA, computes a spectral estimate for a time series using
the Welch overlapped segment averaging method; and
- WOSAPICK, sets up the segments and offsets for WOSA.
- A Fortran software library for numerical differentiation
by pseudospectral methods. The features include:
- derivatives of up to order four for the Fourier, Chebyshev and
Legendre collocation methods based on the Gauss-Lobatto, Gauss-Radau and
Gauss quadrature nodes;
- a choice of methods for computing the derivative/smoothing of
a function including matrix-matrix multiply, even-odd decomposition
- native fast assembly library calls such as General Matrix-Matrix
Multiply (GEMM) from BLAS, FFT and fast cosine/sine
transform where available;
- special fast algorithms (e.g. fast quarter-wave transform and
even-odd decomposition algorithm) for cases when the function has
even or odd symmetry;
- use of Kosloff-Tal-Ezer mapping to reduce the roundoff error
for the Chebyshev and Legendre differentiation;
- extensive built-in and user-definable mapping functions
for finite, semi-infinite and infinite domains;
- built-in filtering (i.e. smoothing) of functions and their
- application of differentiation and smoothing to either the
first or second dimension of a 2-D array;
- conservative and non-conservative forms of derivative
operators (i.e. gradient, divergence, curl and Laplacian
operators) in 2D/3D general curvilinear coordinates; and
- a unified subroutine call interface.
The source code is written in Fortran 90 and uses
the C preprocessor to compile the code into versions for
Cray, IBM R6000, SGI and Sun platforms. The generic
port requires BLAS
and VFFTPACK, both avaiable from Netlib.
The source code is freely available to non-commercial users.
- An Emacs major mode for
editing SGML documents.
- The Parallel Software for Implicit Differential
Equations is a Fortran 77 code for solving
implicit differential equations on shared memory parallel computers.
PSIDE uses the four-stage Radau IIA method. The nonlinear systems
are solved by a modified Newton process in which every Newton iterate
is itself computed by means of the parallel iterative linear system
solver for Runge-Kutta (PILSRK).
This is done so the four stage values can be simultaneously computed
on four processors.
A source code distribution is available which is documented in
user's and reference manuals.
- A molecular orbital plotting package written in
The components of the model are:
A source code distribution is available which requires a
CALCOMP-compatible graphics library
for producing plots.
- PSI1, generates 3-D volume data from molecular orbital
- PSICON, extracts contours from the 3-D data; and
- PSI2, produces plots from PSICON output.
- An emulator for the instruction set
architecture of the PowerPC microprocessor family.
A source code version of this C program is available as is
an extensive user's manual.
- A collection of /proc-based utilities consisting of:
A source code distribution of these utilities is available.
- fuser, which identifies processes using files;
- killall, which kills processes by name;
- pidof, which lists PIDs of processes specified by name; and
- pstree, which shows the currently running processes as
- A set of utilities specifically designed to easily administer large numbers
of user accounts at medium-sized sites (i.e. between 200 and 4000 users).
These programs are tailored for education institutions where classes
change yearly but are flexible enough for use in different environments.
The features iclude the mass addition, removal and disabling of accounts
as well as the mass setting of specified or randomly generated passwords.
A source code distribution is available.
- A set of tools for solving large sparse linear systems
on distributed memory computers.
Solutions are obtained by first partitioning a linear system,
then splitting it according to the partitioning, constructing
a distributed data structure, and finally invoking a preconditioned
Krylov solver for its solution.
It consists of four major
parts: accelerators, preprocessing tools, preconditioning
routines, and message-passing tools. The accelerators and
preconditioners are the functional layer, with the former
based on Krylov subspace methods and the latter needed because
the former tends to work poorly without preconditioning.
The functional modules are designed to be as independent as
possible from data structures and the specifics of the message
passing libraries used.
The non-functional module contains the message passing layer
of the library, which provides an interface between the communication
functions used in the library and those in standard communication
libraries as well as native libraries of some parallel computers.
The routines are designed to exploit redundancy of communications
and asynchronous message passing capabilities to reduce latency
and allow an overlap between computations and communications.
This layer may be phased out in future releases if one of the
standard message passing libraries improves sufficiently to
supply the desired performance characteristics on the appropriate
Source code distributions of P-SPARSLIB are available.
Versions are available for CM5-CMMD, CRAY-T3D,
PVM platforms. A technical
report/user's guide is available in
- A library of Fortran-callable
subroutines for generating two-dimensional technical drawings
or graphics in PostScript format. It supports black and white and
color graphics, and contains 75 subroutines for performing
all the basic operations that are needed for creating
technical graphs. PSPLOT is written in Fortran 77, supports the
standard 35 PostScript fonts, and is platform independent.
- A GNU software
package which is an upwardly compatible replacement for SPSS, a powerful
tool for the statistical analysis of data used at universities
and companies worldwide.
The features of Fiasco include:
The current (9/97) is, in the words of the author, ``woefully
incomplete,'' but it still might be useful for basic tasks.
This was originally called Fiasco.
- support for most transformation language features;
- support for most statistical procedures;
- high quality output formatting including support for
ASCII, IBM-PC box drawing and similar formats, and PostScript; and
- easily ported ANSI C source code.
- A program that repairs common defects in PostScript
files to make them suitable for printing in UNIX environments.
The corrected defects are:
A source code distribution is available.
- translating the CRs found on Mac systems and CR-LFs found on
MS-DOS systems to the UNIX line convention, i.e. LF;
- removing any non-space control characters such as EOF; and
- allowing paper size mismatches for FrameMaker to enable the printing
of US letter size documents on A4 printers and vice-versa.
- A PostScript to PDF
converter. It is a level 1 clone interpreter so Level 2 jobs won't
run on it (although quite a bit of Level 2 is emulated).
It conforms mostly to the PDF 1.1 specification.
A binary distribution is freely available for Linux platforms.
- A program which converts PostScript
and PDF files to other vector graphic formats
so they can be edited graphically.
Pstoedit consists of a PostScript frontend which needs to call
an interpreter like Ghostscript and
the individual backends which are plugged into a framework.
The framework can be used independently from the frontend and
provides a uniform interface to all of the different backends.
The formats supported by the backends are:
debug, XFig, CGM,
Gnuplot, DXF, LWO, Framemaker MIF,
RIB, RPL, JAVA, PS, MET, WMF,
Tgif, Idraw, and dump.
The pstoedit package is written in C++. It can be compiled
It is documented in a man page as well as in a user's guide
in HTML format.
- A set of scripts for converting arbitrary PostScript to
Encapsulated PostScript with an optional preview image.
These can generate EPS, EPSI and EPSF formats.
The use of pstoepsi requires both the
Pbmplus tools and the
- A program that works with
Ghostscript (version 3.33 or
later) to extract plain text from
PDF files (although the latter
requires Ghostscript 3.51 or later).
This is written in C and should compile on almost any UNIX platform
with a C compiler. The documentation is contained within a
- A collection of PostScript-based
macros that allow the
inclusion of color, graphics, rotation, trees and overlays in
- The Parallel Spectral Transform Shallow
Water Model is a message passing benchmark code
and parallel algorithm testbed which solves the nonlinear shallow
water equations (SWE) on a rotating sphere using the spectral
transform method. PSTSWM was developed to evaluate parallel algorithms
for the spectral transform method as it is used in global atmospheric
circulation models. Multiple parallel algorithms are embedded in the
code and can be selected at run-time as can the problem size,
number of processors, and data decomposition.
Six different problem test cases are supported, each with associated
reference solutions and solution and error analysis options.
The PSTSWM source code is available. It is written in
Fortran 77 with VMS extensions and a
small number of C preprocessor directives. Message passing
can be implemented with the MPI,
PICL, or PVM
libraries with the choice being made at compile time.
The package is documented in a user's guide and some technical
reports, all available in PostScript
- A set of utilities to process PostScript source code.
The utilities include:
- psbook, which rearranges pages into
- psselect, which selects pages and page ranges
- pstops, which performs general page rearrangement
- psnup, which puts multiple pages per physical
sheet of paper;
- psresize, which alters the size of the document
on the paper; and
- epsffit, which fits and EPSF file to a given
These programs are all written in C and can be compiled and
installed on generic UNIX platforms.
The programs are documented in individual man pages.
- The Pluto Tools perform various operations on
text files specified on the command line or standard input.
These operations include:
- converting any character to upper
or lower case;
- converting first letters of any word, period,
or paragraph to upper case;
- switching upper case to lower case and vice-versa;
- converting among UNIX, DOS, or MAC text file formats;
- removing enters that are not at the end of a paragraph;
- converting tabs to spaces and vice versa;
- simple encryption;
- stripping the binary parts of files and 8th bits; and
- deleting spaces and tabs at the
end of each line.
- Prometheus TrueColor is a portable true color graphics
system suitable for use in the creation of games, demos, emulators and
other real time graphics software.
It is especially useful as the framework for a 2- or 3-D rendering
PTC is a set of C++ classes that abstracts the
platform-specific details of mode setting, surface handling, pixel
format conversion and display updates.
It allows you to write graphics code once and recompile without changing
anything on all supported platforms.
A feature not found in most other libraries is virtual display modes,
which enable the programmer to work internally in 8-bit indexed color,
RGB565 hilcolor or ARGB8888 true color independently of the display
A source code distribution of PTC is available. It is currently (6/98)
supported on DOS, Win32 and Linux under a wide range of C++ compilers,
and support for X11, BeOS and Amiga is under
Various documentation is available online.
- The GNU portable threads library
is a POSIX/ANSI C based
library providing non-preemptive scheduling for multiple
threads of execution inside
high-performance server applications. All threads run in
the same address space, although each has its own run-time
stack and program counter. The API is similar to the POSIX
threads API in that threads can be spawned and joined. It
differs in that the thread scheduling is done in a cooperative
instead of preemptive manner. The threads are managed by a
priority-and event-based non-preemptive scheduling mechanism,
the goal of which is to achieve better portability and run-time
performance. This event facility allows threads to wait until
various types of events occur including file descriptor I//O,
elapsed timers, raised signals, message port I/O, and thread
and process termination. A source code distribution is available.
This used to be called NPS.
- Pthreads is the POSIX 1003.1c
standard put out by the IEEE standards committee. It is also
the name of a software package obtainable at the given URL.
See Nichols et al. (1996).
- A C++ wrapper library for
- The Platform for Privacy Reference Project is an
activity of W3C to enable Web sites to express their privacy practices
and enable users to exercise preferences over those practices.
Software written using P3P protocols will allow users to be informed
of site practices, to delegate those decisions to their computer
when appropriate, and to allow users to tailor their relationship
to specific sites.
- A Pascal to
C/C++ converter with
a BGI emulation library.
The goal is to produce readable and supportable code which preserves
the style of the original code as much as possible.
This recognizes Pascal dialects compatible with
Turbo Pascal 4.0/5.0 and the ISO Pascal standard IEC 7185:1990(E)
including conformant arrays. It has been (12/98) tested with
Turbo, Oregon, Sun and HP Pascal implementations.
Ptoc can produce both C and C++ output, with the latter allowing
the encapsulation of some Pascal types and constructions into
C++ classes. This makes the mapping between Pascal and C++ more
direct than between Pascal and C.
C++ templates are used to implement Pascal arrays and files and
special classes are used for conformant arrays.
C++ streams are used to implement the Pascal I/O routines and
the same runtime library is used for both targets.
Various Turbo Pascal extensions such as units, strings and some
special types and operations are recognized (but only for the C++ target).
A source code distribution is available which has been
successfully compiled with GCC.
Documentation consists of a combination user's guide and reference manual.
- A Pascal to C
- A software system upon which to build prototyping environments.
Examples thus far of such environments include dataflow-oriented
graphical programming for signal processing, discrete-event
modeling of communication networks, and synthesis environments
for embedded software. If you think about it, just about
any sort of numerical or digital signal processing
package is possible to implement with
this system. After all, linear algebra and matrix operations
are pretty much universal. The source code is available as
well as binaries, including (I think) a Linux binary.
Fair warning: This, like Khoros, is a *huge* package with
a lot of documentation.
- A database tool providing persistence for data which supports
the creation, storage, access and querying of complex objects. It
is designed for high performance access to data and to scale as
both the amount of data and the complexity of queries increase.
PTool doesn't have the overhead of a general purpose object oriented
database and thus is particulary well-suited for applications requiring
high performance access to historical data. It is designed to
query data distributed in a hierarchical storage system and is thus
also well suited for data mining applications. It is also designed
to query data in a multi-computer environment which makes it well
suited for applications requiring numerically intensive queries.
The PTool design
optimizes for high-performance access to historical data,
provides a standard interface to IEEE compliant hierarchical storage systems,
provides support for distributed data queries using message passing for
loosely and tightly coupled clusters of workstations,
supports uniform addressing of large amounts of data using 64 bit
can be integrated in a modular fashion to existing scientific
computing environments, and
includes class libraries for scientific computing.
The current (3/97) release is broadly
compliant and the
next major release is planned to be
The PTool distribution contains the source code including
a variety of container classes, a series of pedagogical examples,
tools for working with tabular data, and other tools including
a basic tool for visualizing series data. The source code is
set up to be compiled on Sun or IBM workstations, but I got it
to compile with fairly minor modifications, i.e. removing the
Sun and IBM specific include files from various programs.
- The Python/Tkinter User Interface is
a Python code development user interface
consisting of an editor and an interpreter
which can be embedded in larger applications or used by itself.
It is an attempt to create an environment in which you can run
code from within the Tk mainloop like in the wish interpreter,
and uses a small framework of classes that can be embedded into a
larger application to facilitate rapid development and testing.
The features of PTUI include:
- automatic indentation and undo;
- a modularization feature to communicate between buffers;
- syntax highlighting;
- an argument to execute an initialization script to change height,
colors, fonts, etc.;
- searchable online help;
- an arbitrary object browser;
- multiple buffers with individual namespaces;
- usability as a frame which can be embedded in another application;
- find/goto and comment/uncomment regions; and
- built-in output and error windows.
A source code version of PTUI is available. Installation
requires Python 1.4 or higher, Tkinter (part of the Python
distribution), and Tcl/Tk (versions
7.4/4.0 through 7.6/4.2).
- A GNU version of a traditional permuted
It can handle multiple input files simultaneously, produce
TeX compatible output, and produce
KWIC (KeyWords In Context) indexes.
- The Paderborn University BSP library is a C library
for supporting the development of parallel algorithms based on the
Bulk Synchronous Parallel or BSP model.
It offers buffered asynchronous message passing between nodes that
is organized in supersteps.
In each superstep a processor can work on local data and send messages,
and at the end of the superstep a barrier synchronization takes place
and all processors receive the messages sent in the previous superstep.
PUB includes functions for both message passing and remote memory
access. Some collective communication operations like broadcast and
parallel prefix are also provided.
Binary distributions are available for several types of platforms
including networks of Linux Intel workstations.
Documentation includes a user's guide in PostScript format.
- A library of generally useful C functions as well
as a framework for building such a library from components provided
by separate sources.
This is an extension of the Standard C library.
The components of the public library include:
A source code distribution is available.
Documentation is mostly via man pages.
- xmalloc, functions for memory allocation;
- dynarr, functions that make it easier to use dynamic
- bitarr, functions for operating on bit arrays;
- cfg, routines for reading and writing configuration files;
- cmp, functions for comparing two array elements of a given
type when given pointers to them;
- expr, functions for evaluating arithmetic expressions given
as a string;
- fname, functions for manipulating
POSIX-style filenames; and
- stack, functions for operating on stacks.
- The printer utility program is a GUI utility
for maintaining printers under Linux.
It currently (3/00) supports only Lexmark Optra Color 40 and 45 printers.
- The Portable UNIX Shell Environment is a
set of Korn shell login environment files
and nearly 80 ksh,
Expect scripts for performing various tasks.
The scripts include those involving text analysis and processing,
file and directory analysis and processing, the system environment,
printing and tape drives, disk space management, system monitoring,
security, performance analysis, system configuration analysis and
The features of the ksh login environment
- an expanded shell prompt that can be set to any of several
available formats and displayed in boldface or normal font;
- preconditioning of the shell environment such that the standard
environment variables are defined, e.g. $COLUMNS, $FCEDIT,
$HISTSIZE, $MAILCHECK, etc.;
- initialization of the TERM variable and stty options;
- an option to alias vi to a script that will
back up a file before running vi on it;
- a predefined function for listing files sorted by access time in a long
list format with access times instead of modification times;
- predefined functions for a compressed-format listing of all files
in a large directory or directory tree;
- predefined functions for commonly-used options of the ls
- predefined aliases for commonly-used history commands.
- A package for reconstructing phylogenetic trees from molecular
sequence data by maximum likelihood which implements a fast
tree search algorithm (i.e. quartet puzzling) that allows for the
analysis of large data sets and automatically assigns estimations
of support to each internal branch.
It incorporates rate heterogeneity (invariable sites plus
Gamma distributed rates) in all available substitution
models (e.g. TN, HKY, and F84 for nucleotides; Dayhoff, JTT and
mtREV24 for amino acids).
PUZZLE computes pairwise maximum likelihood distances as
well as branch lengths for user specified trees. It offers a novel
method, i.e. likelihood mapping, to investigate the support of
internal branches without computing and overall tree.
Other features include:
- computation of clock-like branch lengths (and also for
amino acides and non-binary trees);
- an automatic likelihood ratio clock test;
- the display of most probably assignment of rates to sites;
- identifying groups of identical sequences;
- reading multiple input trees;
- the Kishino-Hasegawa test to check whether trees are
- the BLOSUM 62 model of amino acid substitution; and
- application of SH model to 1st and 2nd codon positions.
PUZZLE is written in C and can be compiled and used on UNIX,
VMS, Mac and MS-DOS platforms.
It is documented in a user's manual available in both
HTML and PostScript format.
- A enhancement of PVM that produces animations
of the execution of PVM applications.
This is actually a couple of separate subsystems, one of which
provides fine-grained, post-mortem visualizations of PVM
applications, and the other which provides on-line, low-overhead,
minimal perturbation visualizations.
Both are built on top of the POLKA
visualization package and can be used on packages with both
POLKA and PVM installed.
- The Parallel Virtual File System is a project
to explore the design, implementation and potential uses of parallel
PVFS is designed for use in environments consisting of workstation
clusters and consists of a set of daemons and a library of application
interface calls that operate on top of an off-the-shelf operating
system using standrd network protocols for communication.
The features include:
The application interfaces currently (2/99) supported include:
- file striping;
- file partitioning;
- collection I/O;
- application-oriented interfaces; and
- a stream-based data transfer mechanism which attempts to improve
throughput by reducing the number of control messages and removing
stripe and partition dependence on message sizes.
This is available in source code and RPM formats.
Documentation includes a user's guide and some technical papers.
- UNIX-style I/O with file partitioning;
- multidimensional block I/O;
- UNIX-style collective I/O; and
- 2-D collective I/O for common block decompositions.
- The Parallel Virtual Machine) software
is a package that enables
a collection of heterogeneous computers to be used as a coherent and
flexible concurrent computational resource.
PVM is an integrated set of software tools and libraries which
emulates a general-purpose, flexible, heterogeneous
concurrent computing framework on interconnect computers of
The system consists of two parts:
a daemon called pvmd which resides on all computers comprising
the virtual machine, and a library of PMV interface routines containing
a functionally complete repertoire of primitives needed for cooperation
between the tasks of an application.
PVM currently (5/97) supports C, C++ and Fortran language interfaces.
The C and C++ language bindings are implemented as functions while
the Fortran bindings are implemented as subroutines
The principles upon which PVM is based include:
The January 1998 issue of the
Linux Journal contains an
article on using PVM with Linux.
- a user-configured host pool containing a list of computers upon
which computational tasks can be performed which can be added to
and deleted from before or during operation;
- translucent access to hardware where application programs may view
the hardware environment either as an attributeless collection of
virtual processing elements or can exploit the capabilities of
specific machines in the host pool by positioning specific tasks
on the most appropriate machines;
- process-based computation in which the basic unit of parallelism
is a task, i.e. an independent sequential thread of control which
alternates between communication and computation;
- an explicit message-passing model in which collections of computational
tasks perform the workload for an application using data-, functional-,
or hybrid-decomposition and cooperate by explicitly sending and receving
messages to one another;
- heterogeneity support in terms of machines, networks, and applications; and
- multiprocessor support wherein PVM uses the native message-passing
facilities on multiprocessors to take advantage of the underlying
Packages which use or enhance PVM in some way include:
- ADAPTOR, an HPF compilation
system which transforms HPF code into PVM calls;
- Adsmith, an object-based DSM system built on
top of PVM;
- A++/P++, a set of C++
classes for numerical computations with structured grids;
- BLACS, a version of BLAS
for message passing systems;
- BSPlib, a library implementing the BSP model
of parallel computation;
- CG, a conjugate gradient package for the iterative
solution of linear systems;
- CHARM, a parallel programming system;
- CL-PVM, a Common Lisp
interface to PVM;
- CODE, a visual programming system for turning
sequential into parallel programs;
- Condor, an environment for managing very large
collections of distributed workstations;
- Converse, a parallel programming framework
for developing portable programs;
- COSMICS, a set of Fortran
programs for cosmological modeling;
- C*, an explicitly parallel version of C;
- CUMULVS, an infrastructure library that allows
data to be extracted from running parallel simulations and visualized;
- DOM, a radiative transfer model for remote sensing
- Dome, a C++ library of
distributed objects for parallel programming;
- DPMTA, a library for implementing various
multipole algorithms for N-body simulations;
- DQS, a distributed queueing system;
- DSU, a seismic applications toolkit;
- EGO, for performing calculations in molecular
- Emu/fdtd, an electromagnetics simulator;
- FASTA, tools for biological sequence analysis;
- fsolver, a solver for the incompressible
- GALOPPS, a flexible
genetic algorithm package;a
- GHC, a Haskell language environment;
- GLU, a high-level system for granular
- HPF, a set of extensions to
Fortran to support parallel programming;
- JavaPVM, a Java
interface to PVM;
- jPVM, another Java interface to PVM;
- KLIC, an implementation of the concurrent
logic programming language KL1;
- LASSAP, a parallel sequence analysis package;
- LPARX, provides support for scientific calculations
involving particle and adaptive multilevel finite-difference methods;
- Maisie, a simulation language for the sequential
and parallel execution of discrete event simulation models;
- mEDA-2, a PVM extension providing virtual shared
memory for intertask communication and synchronization;
- NAMD, an object-oriented molecular dynamics
- Pade, a system for developing parallel applications
for heterogeneous networked computers;
- Parallaxis, a structured programming language
for data parallel programming SIMD systems;
- Para++, C++ classes for
encapsulating message passing primitives into a higher level of abstraction;
- PCCM, a parallel version of the Community Climate
- Perl-PVM, a Perl
extension for PVM;
- PFSLib, a library offering parallel access to
files for parallel applications;
- PICL, a library implementing a message passing
- PIM, Fortran routines
for solving systems of linear equations;
- PIPS, a data conversion package;
- PIOUS, a complete parallel I/O system for PVM;
- PLUS, allows interoperation with
MPI and PARIX;
- PM2 High Perf, a portable multithreaded
for highly parallel applications;
- POV-Ray, a parallel
ray tracing package;
- ppmake, a parallel make
- PRM, a manager for running applications on a network
- Proteus, a rapid prototyping system for
developing parallel algorithms;
- P-SPARSLIB, tools for solving large, sparse
linear systems on distributed memory computers;
- PSTSWM, a benchmark spectral transform
shallow water model code;
- PVaniM, a PVM extension that produces animations
of the execution of applications;
- REGAL, a distributed
genetic algorithm package;
- ScaLAPACK, for performing dense and band linear
algebra computations on distributed memory computers;
- SEA, an ocean circulation model;
- Surface Evolver, for studying surfaces
shaped by surface tension and other energies;
- tclpvm, a set of PVM extensions to
- Tkpvm, a Tcl/Tk
interface to PVM;
- TPVM, a threads-oriented
subsystem for PVM;
- TRAPPER, a graphical programming environment;
- VIC, a package for describing CFD algorithms
in data parallel fashion;
- VPE, a visual parallel programming environment;
- WAMM, a graphical tool for handling repetitive
administration tasks; and
- Xi, an interactive programing language with
PVM supports a wide variety
of platforms (including those running Linux) that may be interconnected
by a variety of networks. Extensive documentation is available,
including a PostScript file of a recently published book about PVM.
Alexandrov and Dongarra (1998) and
Geist et al. (1994).
- A Python module for accessing the
PVM C libraries.
- Threads-oriented PVM is an experimental subsystem for
PVM which supports the use of light-weight
processes or threads as the basic unit
of scheduling and parallelism.
TPVM is designed for ease of portability with the changes required
for a different platform, OS, or threads implementation isolated in
a single module.
The thread model overcomes several of the disadvantages of a
process-oriented model, principal among which are task initiation
and scheduling costs, overlapping computation and communication
on a single processor, smaller granularity, exploiting
small-scale SMMPs, and supporting event- or data-driven active
message based computation.
- A package of three closely related equation solvers:
The solvers have some code modules in common, chiefly a module of
vector kernels and linear system solver based on a scaled
preconditioned GMRES method.
- PVODE, for systems of ODEs;
- LINSOL, for systems of nonlinear algebraic equations; and
- IDA, for systems of differential-algebraic equations (DAEs).
PVODE - an extension of a sequential solver package called
CVODE - is a solver for large systems of ODEs on parallel machines.
It contains methods for solving both stiff and non-stiff IVPs,
with several integration methods including the variable coefficient
forms of the Adams and Backward Differentiation Formula methods.
The implicit time step linear systems are solved via iterative,
preconditioned Krylov solvers with the preconditioner either user-supplied
or one included in the PVODE package.
This is written in C although callable from either that
or Fortran, and the parallelization is handled
via calls to MPI.
The closely related KINSOL solver for nonlinear algebraic
equations uses inexact Newton methods with line search strategies
for accelerated convergence. Both serial and parallel versions are
The IDA solver uses backward differentiation formula methods
to solved DAEs and is also available in serial and parallel versions.
The serial version includes both direct and iterative (GMRES) methods
for solving linear systems, while the parallel version includes only
The entire PVODE package is being incorporated into
An overall user guide and documentation for each component are
available in PostScript format.
- A fairly complete JPEG
baseline package targeted toward simulation
and research (where a baseline system is defined as the minimal
system needed to claim JPEG compatibility).
The system includes a flexible encoder which can generate
compressed files through different valid strategies which can
also decode all possible JPEG baseline compressed files.
The source code for PVRG-JPEG, written in C, is available and
can be compiled on most generic UNIX systems with a C compiler.
The package is documented in a 55 page PostScript technical
manual and user's guide.
- A verification system, i.e. a specification language integrated with
support tools and a theorem prover.
It is intended to capture the state-of-the-art in mechanized
and to be sufficiently rugged to be used for significant
The PVS system consists of a specification language, a number of
predefined theories, a theorem prover, various utilities, documentation,
and several examples from a variety of application areas.
PVS has thus far been chiefly applied to algorithms and
architectures for fault-tolerant flight control systems and to
problems in hardware and real-time system design.
The PVS language is based on classical, typed higher-order logic
with base types including uninterpreted types that may be
introduced by the user as well as built-in types such as
booleans, integers, reals, and the ordinals.
Type constructors include functions, sets, tuples, records,
enumerations, and recursively-defined abstract data types such
as lists and binary trees.
The theorem prover provides a collection of powerful primitive
inference procedures which are applied interactively under user
guidance wihtin a sequent calculus framework.
The inferences include propositional and quantifier rules, induction,
rewriting, and decision procedures for linear arithmetic, with the
implementations thereof optimized for large proofs.
PVS uses Emacs to provide an integrated
interface for the language and prover. Extensive help, status
reporting, and browsing tools are available as well as the
capability of typesetting specifications in
LaTeX. Proof trees and theory hierarchies
can be displayed graphically using Tcl/Tk.
PVS is implemented in Common Lisp
and runs on most workstations with a Common Lisp compiler
with an integrated CLOS.
It is supported on Sun SunOS and Solaris, IBM AIX, and Linux Intel
running Redhat 4.0 or greater.
A plethora of manuals are available for PVS, all in
PostScript format. These include
an overview, a quick reference, a language manual, a system
manual, a prover manual, a tutorial, and more.
The package are freely available via the Web but a license
agreement must also be signed to use it.
Full use of this package requires Emacs,
Tcl/Tk and LaTeX.
- A VRML parser library written in
- A parallel Web server harness which provides a request-forwarding
context-switching infrastructure for building
HTTP services over a cluster
of workstations. Popular servers like Apache, NCSA, Spinner,
Plexus, etc. can be hooked up onto the harness for parallel
processing HTTP requests. This provides the most benefit on
workstation clusters with fast interconnects like ATM or on
distributed memory parallel computers, although it can be used
over ethernet connections. Advantages which can be derived
from pWEB include load balancing (i.e. CPU intensive CGI requests
can be distributed across workstation nodes) and distributed
file I/O (i.e. file access congestion can be decreased by
directing file requests to a specific node's local disk).
The pWEB package includes the source code which is written
in C. The Makefile includes parameters to compile on UNICOS,
SGI IRIX, IBM AIX, Sun Solaris and SunOS, DEC OSF/1, and Linux
systems. The documentation is included in the package and
is also available online.
- A program developed to allow for the convenient visualization
of n-dimensional econometric data which is useful for
displaying all types of data.
PXI offers publication quality output, a convenient
graphical user interface (GUI), and powerful data manipulation
The features of PXI include:
- graph annotation in a variety of fonts;
- fitting experimental data including the plotting of
the likelihood function, various tokens to annotate each
data point, and the numerical annotation of data points;
- a built-in algorithm for generating complete quantal response
correspondence for normal form games;
- a choice of graph types including each data column plotted
against the dependent variable on a rectangular grid,
- two data columns plotted on a triangular grid to simulate
3-D graphics, and
- one data column plotted against another.
PXI is a shareware package with binaries available for
MS Windows, Sun SunOS and Solaris, HP-UX, IBM RS/6000, and,
upon request, Linux platforms.
- Pascal eXtension for Scientific Computation is
a version of Pascal that significantly simplifies
scientific and technical programming.
It is particularly well suited for the development of numerical
algorithms that deliver highly accurate and automatically verified
The features of P-XSC provide:
P-XSC contains Standard Pascal and is thus usable for generic
Pascal programming tasks as well.
- a large number of predefined data types with arithmetic
- predefined, highly accurate functions for real and
complex numbers and intervals as well as for the corresponding vectors and
- modules for dividing programs into smaller units;
- an operator concept;
- functions and operators of arbitrary result type;
- overloading of functions, procedures and operators;
- dynamic arrays;
- access to subarrays;
- rounding control by the user; and
- accurate evaluation of expressions.
Source code and binary versions of a P-XSC compiler are available,
with one of the latter being for Linux Intel platforms.
A compiler manual is available in PDF format.
- Tools for climate data analysis that make extensive use of
The package contains:
- I/O functions for handling ASCII and NetCDF
- time handling routines to convert between date and Julian day;
- an interface to the DCDFLIB library of
- empirical orthogonal function analysis routines based on the
singular value decomposition (SVD);
- routines for calculating the SVD;
- a multivariate digital filter based on the Kolmogorov-Zurbenko
and Lanczos filters;
- kernel-based probability density functions; and
- differential operators on the sphere.
- A Python modoule implementing geometric
or Clifford algebras, i.e. an algebra of vectors of given dimensions
In Clifford algebra the inner (dot) and outer products (the latter a
generalized relative of the 3-D cross product) are unified in an
invertible geometric product. Scalars, vectors and higher-grade
entities can be mixed freely and consistently in the form of
- A modified form of the standard Python
debugger pdb with augmented features making it suitable for
use with DDD.
The changes required for the port added some new features to
pdb including temporary breakpoints, conditional breakpoints,
an ignore breakpoint count, and an easier way to set breakpoints
in modules outside the current one.
Source code distributions are available.
- A tool for connecting Fortran routines
Pyfort translates an input file describing the Fortran
functions and subroutines to be accessed from Python into
a C language source file defining a Python
- The Python Network Grapher is a tool designed to
give visible insight into network usage. It summarizes network
traffic flow through a GUI and plots a usage graph for the current
day as well as overviews for the week, month, and year.
- A Python interface to the
OpenGL widget set.
- A collection of Matlab tools for multi-scale
The PyrTools set includes programs for:
recursive multi-scale image decompositions including Laplacian
pyramids, QMFs, wavelets, and steerable pyramids to operator on 1-D
or 2-D signals of arbitrary dimension;
fast 2-D convolution routines with subsampling and boundary handling;
fast point operations, histograms, and histogram matching;
fast synthetic image generation;
and display routines for images and pyramids.
- A Python package of mixed integer
linear programming modules that provides basic symbolic programming
tools for constructing, solving and optimizing systems of
linear equations and inequalities.
It includes an implementation of the classic simplex linear
optimization algorithm as well as
a filter for parsing and optimizing linear models encoded using the
standard MPS format.
This requires the NumPy set of numerical
extensions for Python.
- An interpreted, interactive,
It has modules, classes, exceptions, high level
dynamic data types, and dynamic typing along with interfaces
to many system calls, libraries and various windowing systems
Mac, MFC, STDWIN). New modules are
easily written in C or C++, and it is usable as an extension
language for applications that need a programmable interface.
The source code is available and easily installable on UNIX
platforms, and binaries are available for many platforms
including Linux. A nicely done
can be found at
UnixWorld Online. The
Jan. 1996 issue of the Linux Journal
has an introduction to Python by Jeff Bauer.
A project to develop a matrix language called
is well under way as of 7/96.
See Lutz (1996) and
Watters et al. (1996).
Related packages which are written in, extend or use Python in
some way include:
- A set of utilities providing a standard mechanism for building,
distributing and installing Python modules or
The Distutils provide a set of classes to implement the normal tasks
involved in such work, e.g. building C extensions,
processing documentation, installing libraries, compiling files to
It also provides a standard way for module developers to give users
access to these classes via a simple Python script.
- The Python Imaging Library adds an image
object to the Python interpreter. This
allows loading image objects from a variety of file formats as
well as applying a large set of image operations to them.
The operations which can be performed using the PIL objects include:
color manipulations including
bilevel, greyscale, palette, true color (RGB), true color with
transparency, and color separation (CMYK); copying, cutting, and
pasting; transparency; channel and point operations; color transforms
including matrix operations; and image enhancement including
File formats which can be opened, loaded, and saved are: BMP, EPS (with
Ghostscript), GIF, IM,
JPEG, MSP, PNG,
PPM, TIFF and XMB.
Read only formats are CUR, DCX, FLI, FLC,
GBR, GD, ICO, IMT, PhotoCD, PCX, PSD, TGA, SGI, SUN, and WMF, and
save only formats are PDF and EPS (without GhostScript).
PIL can be installed on most platforms which support Python.
Full functionality requires the aforementioned Ghostscript as
well as the IJG JPEG library and the ZLIB library.
The package is documented in a 40 page manual in
- A Python to C translator
that attempts to speed up Python code by removing a significant
fraction of the CPython virtual machine (VM) overhead.
- A package that basically binds together the
Python interpreted language and
XForms GUI builder.
This faciliates the quick and easy construction of
GUIs on many UNIX/X Window platforms. It is object oriented,
extensible, and allows the non-graphic portions of the program
to be written in Python, C or C++.
[ home /
Up: Linux Software Encyclopedia