- daemontools
- Several programs to perform and automate some system tasks.
The programs include:
- supervise, which starts a service and restarts it if it dies;
- svc, which stops, pauses, or restarts a service on request;
- svstat, which prints a one-line status report;
- cyclog, which writes a log to a disk, automatically synchronizes
it every 100 KB, and automatically rotates it to keep it below 1 MB;
- accustamp, which puts a precise timestamp on each line of
input in TAI format;
- tailocal, which converts TAI timestamps to local time;
- usually, which watches a log for lines that don't match
specified patterns and copies the lines to stderr;
- errorsto, which redirects stderr to a file;
- setuser, which runs a program under a user's uid and gid and,
unlike su, doesn't gain privileges or check passwords and cannot be
run except by root.
A source code distribution is available.
[ftp://koobera.math.uic.edu/www/daemontools.html]
- DAEPAK
- See MANPAK.
- DAFLOW
- A program for streamflow routing in upland channels or channel
networks.
DAFLOW is a digital model for routing streamflow using the diffusion
analogy form of the flow equations in conjunction with a Lagrangian
solution scheme.
It is not applicable and therefore should not be used where backwater
effects are significant or where flow reversals occur.
It uses only two adjustable coefficients per branch, i.e. the wave
celerity and wave attenuation coefficient, and these must remain
constant.
The model is designed to provide reasonable predictions of discharge
and transport velocity using a minimum of field data and calibration.
It is designed to support the BLTM transport
model, but should also be useful for general flow routing
applications.
A source code distribution of DAFLOW for UNIX platforms is
available.
The primary documentation is contained within
Jobson (1989).
This is part of the USGS
Water Resources Applications Software
collection.
[http://water.usgs.gov/software/daflow.html]
[http://www.geogr.uni-jena.de/software/daflow.html
]
- DAGH
- The Distributed Adaptive
Grid Hierarchy is a data management
infrastructure for parallel adaptive mesh refinement (AMR) techniques.
It consists of two components: a set of programming abstractions in
which computations on dynamic hierarchical grid structures are
directly implementable and a set of distributed dynamic data structures
that support the implementation of the abstractions in parallel
execution environments and preserive efficient execution while
providing transparent distribution of the grid hierarchy across
the processing element execution environment.
DAGH features include:
- transparent access to scalable distributed
dynamic arrays/grids/grid-hierarchies,
- multigrid/line-multigrid
support within AMR,
- a shadow grid hierarchy for on-the-fly error
estimation,
- automatic dynamic partitioning and load distribution, and
- locality, scalability, portability and peformance.
High level programming abstractions include application objects,
coarse-grained data parallelism, Fortran compliant data
storage, and more. DAGH also includes HDF-based I/O support,
interactive visualization support (via xgraph), and checkpoint/restart
support.
The DAGH package includes the source code which will run on
IBM SP2, SGI PowerChallenge, Cray T3D, and networked UNIX
workstations. The latter port requires the
MPI package and, as mentioned,
visualization support requires the xgraph package.
A preliminary (3/97) user's guide is available in PostScript
format. DAGH is part of the
Computational Toolkit for Numerical Relativity
.
[http://www.caip.rutgers.edu/~parashar/DAGH/]
- DAOPHOT
- A Starlink Project package
is a stellar photometry package designed to deal with crowded
fields. DAOPHOT performs various tasks including finding
objects, aperture photometry, obtaining the point-spread
function, and profile-fitting photometry. Profile fitting
in crowded regions is performed iteratively to improve the
accuracy of the photometry.
The package consists of the DAOPHOT program and three
additional routines which produce output files from results obtained with
DAOPHOT (which cannot by itself display results).
These routines are:
DAOGREY, which produces a grey scale image of the data;
DAOPLOT, which will indicate the positions of objects found
with DAOPHOT on top of the grey image produced by DAOGREY;
and DAOCURS, which will put up a cursor on the display to allow
positions to be measured from the screen.
A binary version of the DAOPHOT package is available for
Linux Intel, DEC OSF/1, and Sun Solaris platforms.
It is documented in a user's manual available in
PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
- DAP
- The Digital Audio Processor is a sound file
editor available as either source code or a Linux ELF
binary.
[http://www.cee.hw.ac.uk/~richardk/]
- DASSL
- A Fortran 77 package which solves a system of differential-algebraic
equations (DAEs) of the form g(t,y,y') = 0.
It uses the backward differentiation formulas of orders one
through five to solve a system of the above form for y and y'
with initial values for both as input.
The system is solved for some specified time period t0 to t1.
Single and double precison versions called, respectively,
SDASSL and DDASSL are available.
A source code distribution of DASSL is available.
The routines are written in Fortran 77 and documented via
comment statements contained within each source code file.
This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
- data formats
- Software dealing with data formats includes:
- CDF, a self-describing data abstraction for the
storage and manipulation of multidimensional data in a
discipline-independent format;
- CIF, a standard means of information exchange
in crystallography;
- FITS, the format adopted by the astronomical
community for data interchange and archival storage;
- GeoTIFF, a TIFF-based interchange
format for georeferenced raster imagery;
- GRIB, the World Meteorological Organization
standard for gridded meteorological data;
- HDF, for the storage and exchange of scientific
data;
- NetCDF, an interface for scientific data
access which implements a machine-independent, self-describing,
extendible file format;
- OpenMath, a standard for communicating
mathematical objects between computer programs;
- SAIF, a Canadian national standard used for
the exchange and archiving of geospatial data;
- SDTS, a standard for transferring earth-referenced
spatial data between dissimilar computer systems;
- database
- The Linux Database
site is a good place to search
for information about using databases on Linux platforms.
Database software available for Linux platforms includes:
- ACEDB, an object-oriented DB originally
developed to organize molecular biology data but with wider application;
- BeagleSQL, a client/server DB which uses
SQL;
- CACTVS, a chemical information database system;
- cdb, a fast, reliable and lightweight package
for creating and reading constant databases;
- Coral, a project to develop a deductive database
system and investigate its use in several application domains;
- DataSplash, a database visualization
environment;
- DB, the latest version of the classic Berkeley
db utilities;
- dbedit, a system for integrating and
developing web DB applications that is part of the GNU
project;
- ESCHER, a visual database editor which extends
the SQL model via nested tables, lists, sets, etc.;
- FLORID, an object-oriented database
prototype whichuses F-logic as a definition and query language;
- Gadfly, a Python
package providing relational database functionality;
- gdbm, the GNU library of
database functions;
- GiST, a C++ library for
implementing a database indexing scheme called Generalized Search Tree;
- Glimpse, a powerful indexing and query system;
- GSS, a relational database system which supports
the full SQL89 dialect with some extensions from SQL92;
- id-utils, a set of GNU
utilities for implementing an ID database;
- IronDoc, a structured storage system for
creating object networks of multimedia content;
- Kappa, a parallel database management system;
- LEAP, a relational DB management system written
as an educational tool;
- LINCKS, a DB system developed for complex
information system applications;
- Mariposa, a distributed DB management system
that addresses fundamental problems in the standard approach to distributed
data management;
- MDBMS, a relational DBMS for complex database
work;
- MG, a collection of programs which comprise a
full-text retrieval system for huge databases;
- mSQL, a DB designed to provide fast access to
stored data with low memory requirements;
- MUMPS, a programming language oriented towards
database applications;
- mysql, a small and fast relational DB;
- OPT++, a tool for database query optimization;
- PostgreSQL, a DBMS research prototype that
used to be called POSTGRES and Postgres95;
- PTool, a DB tool providing data persistence
and which supports the creation, storage, access and querying of complex
objects;
- Qddb, a database suite with many functions
and which supports many search techniques;
- Quixote, a deductive, object-oriented database
language that's part of the ICOT project;
- Remembrance Agent, a program that
displays a list of documents relevant to a user's present context that
it locates in a database back-end;
- ROL, a deductive object-oriented database system;
- SHORE, a project to design a persistent object
system to serve the needs of a wide variety of databases;
- SQRL, a project to build an ANSI SQL-92 compliant
DB;
- Swish, a tool for creating indexes of files
and searching them;
- TSIMMIS, a project to develop tools for the
rapid integration of heterogeneous information sources including structured
and semistructured data;
- WDB, a toolkit for integrating SQL databases
into the Web;
- WODA, a database written in
Perl for creating flat multimedia databases;
- xmbase-grok, a simple database manager
and user interface builder; and
- XSB, a research-oriented logic programming and
deductive database system.
- DATAPLOT
- This is a powerful, flexible
scientific, engineering, statistics, mathematics and graphics system.
It is an interactive, command-driven language/system with
English-like syntax developed at the National Institute of
Standards and Technology in response to data analysis problems.
An early version of a graphical user interface is available as
of July 1995 that requires both the
TclTk and
Expect packages.
The capabilities include raw graphics (e.g. 2-D, 3-D, contour and color
plots), analysis graphics (e.g. plotting data and functions, mixing
data and functions, etc.), presentation graphics (e.g. Hershey fonts,
Greek symbols, PostScript output, etc.), summary graphics (e.g. pie
charts, histograms, error bar plots, X-Y plots, etc.), diagrammatic
graphics, graphical data analysis (e.g. scatter plots, probability
plots, etc.), exploratory data analysis (e.g. box plots, robust
smoothing, linear/polynomial/nonlinear fitting, general
transformations, bootstrap plots, etc.), time series analysis (e.g.
lag plots, autocorrelation plots, spectral plots, Fourier plots,
etc.), smoothing, fitting, statistics and probability calculations,
multivariate analysis, experiment design, a large number of
math functions, and much more.
Further details about the
DATAPLOT capabilities
are available.
The source code is available as well as binaries for Convex, DEC Alpha,
HP-9000, IBM RS6000, SGI and Sun platforms. It should install on
other UNIX platforms with a Fortran compiler and a C compiler, the
latter being necessary for X11 support. There is also a source
code only C version of the program created by running the Fortran
source code through the f2c program.
The documentation is
contained in several flat ASCII text files, including files describing
new features, the command set, and several help files.
The README file says that hardcopy documentation is also
available.
I compiled the C source code version on my Linux box with GCC using a
DATAPLOT Makefile
rather than with the supplied shell scripts. The stripped
ELF binary is 11+ Mb and running it also causes about 9 Mb
of uninitialized data arrays to reside in RAM, so I'd recommend
at least 24 Mb of RAM to run this thing. I've also created
hypertext wrappers for the
overview
,
new features
,
command dictionary
,
and
command overview
documents that will allow you to get a better feel for this
package without having to download an 8 Mb documentation file.
If the web page is down, try the
DATAPLOT FTP site
.
[http://www.itl.nist.gov/div898/software/dataplot.html/]
- Datapult/PF
- A tool for generating dynamic HTML documents.
PF can be used to create and process user input forms without
writing a CGI program. The pages created
can automatically react to the capabilities of the browser as
well as information sources such as SQL databases or user-written
modules.
It can be used in a server mode where a pool of processes in
continually running in its own native server pool with a CGI stub
client. There is a module for the Netscape Enterprise server and
one under development for Apache.
It can run as a
FastCGI server under the Openmarket
or Apache servers.
PF can also be used as a scripting language for the shell to
perform, e.g., complex database manipulation tasks via utility
scripts.
A source code distribution is available as are binary versions
for Linux Intel and Alpha. The documentation is online and
still a bit sketchy as of this writing (2/98).
[http://datapult.com/products/pf/]
- DataSplash
- A database
visualization environment which combines a sophisticated
navigation model with a paint program interface with which users can
create custom visualizations.
In addition to the standard features of a paint program DataSplash
contains a window which shows rows from a database table to be
visualized. Each row is assigned a location on the drawing canvas,
i.e. the rows are scattered across the canvas giving an effect
similar to a scatter plot. At any point the user can select an
object on the canvas and duplicate it for every row in the database
table, which gives the effect of splashing paint across the canvas.
DataSplash also incorporates a sophisticated navigation model with
which users can zoom, pan, teleport, and link to other canvases.
Object changes representation as users zoom closer to them, and
a layer manager is provided which allows users to program the
way objects behave during zooming. Portals (windows which go to
other canvases) can be specified for some or all objects on the
canvas.
A beta (4/97) version of DataSplash is available as source code
or in binary format for DEC Alpha, HP/UX, Linux Intel, and Sun
Solaris platforms. Documentation is available in the form of
an online user's manual in HTML format.
[http://s2k-ftp.CS.Berkeley.EDU:8000/tioga/]
- DAVID
- The DAta VIsualization and Diagnostics package
an interactive visualization environment that allows the user
to interact with numerical or simulation data.
In this environment the user can interactively allocate memory
for the data, manipulate and display it. These tasks can also
be specified in an executable command file. The results can
be displayed in an X Windows screen or used to create a
PostScript file.
Features include support of multiple windows and displays, black and
white and color screen support, a C language-like programming
syntax, support for multi-dimensional variables in memory and disk
in multiple formats and of different types, automatic conversion from
one variable type to another, a large set of built-in mathematical
functions, a large library of display routines (e.g. X-Y plots,
2-D contour plots and images, 3-D display of 2-D data rrays with
hidden line removal, etc.), interactive graphics animations with
movie-like capabilities, an interactive graphics editor, an
interactive diagnostics system, interactive feature tracking,
and interactive color map editor, and an interactive threshold
changer.
It is written in C to run on UNIX systems under X Windows using
the Athena widget set and other standard X11 libraries.
There are binaries for SGI, SUN, DEC Alpha, IBM and HP platforms,
and the source code is also available. The package is documented
in a 113-page PostScript user's manual.
[http://vizlab.rutgers.edu/vizlab_group_files/
RESEARCH/VISIOMETRICS/DAVID/index.html]
- daVinci
- A visualization tool for automatically drawing high quality
direct graphs written using the
ASpecT functional language.
It can be used to visualize hierarchies, dependency structures,
networks, configuration diagrams, dataflows, etc.
It combines hierarchical graph layout with powerful interactive
capabilities and an API for access from a remote application.
The features of daVinci include:
- automatic graph layout with edge-crossing and bend minimization;
- interactive fine tuning for a given layout;
- control of node and edge attributes including color, font, shapes,
icons, etc.;
- interactive abstraction operations such as collapsing subgraphs
and hiding edges;
- scaling functions for getting an overview;
- navigation and search features for browsing a graph;
- multi-graph, multi-view, and survey-view visualizations;
- a choice of layout orientations;
- encapsulated PostScript output;
- a Motif-like interface with a file
browser, icon bar, keyboard support, etc.; and
- an integrated help system with online documentation.
The daVinci package is available in binary format for
several UNIX platforms including Sun SunOS and Solaris,
HP-UX, IBM-AIX, SGI IRIX, Digital UNIX, DEC Ultrix, and
Linux Intel (ELF and a.out).
The documentation is available online in HTML
format in the built-in help system.
[http://www.Informatik.Uni-Bremen.DE/~davinci]
- DB
- The Berkeley DataBase is a toolkit providing embedded
database support for both traditional and client/server applications.
This is the newest version of the classic Berkeley db utilities.
DB includes APIs for C, C++, Java and
Perl.
The features include:
- various database access methods including B+ tree, extended
linear hashing, fixed/variable length records, keyed and sequential
retrieval, partial-record data storage and retrieval, architecture
independent databases, and more;
- transaction support including multiple readers/single writer
locking, two-phase page-level locking, degree 3 isolation, and
before and after image logging;
- database recovery after application or system failure and
online database backups;
- a modular architecture in which object handles are free-threaded
and therefore support concurrent access via threaded programs; and
- extensive administrative functionality via both standalone utilities
as well as through the API.
A source code distribution of DB is freely available for non-commercial
applications. It is written in C and can be compiled on most UNIX
systems.
Documentation is via an extensive set of man pages available in
various formats.
[http://mongoose.bostic.com/db/]
- dbedit
- A system for integrating and developing web database applications
that has been adopted as part of the GNU
software project.
Dbedit separates the display of information from its storage.
A database is displayed by creating an HTML form and then running a Perl
script on it which generates a CGI wrapper for the script.
This method allows arbitrary Perl code to be added to database
applications.
An application can be integrated with any database by writing
a driver routine since display and storage are separated.
Thus the database implementation can be changed without rewriting
forms, and forms can be changed without rewriting the databse.
A source code distribution of dbedit is available. It is
written in Perl and requires version 5.
A manual is included in the distribution.
[http://admin.gnacademy.org:8001/uu-gna/tech/dbedit/dbedit.html]
- DBOX
- A full-featured BBS package designed for
heavily-used, professional systems running Linux.
The features of DBOX include:
a user database designed for a large number of users;
Janus/ZConnect/UUCP mail transfers;
command-line and menu system interfaces;
keeping track of online time, net traffic, and email for charging purposes;
SLIP for Internet access with automatic IP address assignment;
support for CD-ROM downloads;
chat rooms;
file boards;
a mailing list daemon and mail file server;
Internet interfaces via POP3 and HTTP/HTML;
a homepage manager for user-designed homepages;
online shopping with user accounts and customizable logos/images;
and more.
This is currently (1/98) available only in binary format
for Linux Intel systems.
It is also currently available only in a German version (both
software and documentation), although a English version is in
the works.
It is currently free for non-commercial uses.
[http://sunsite.unc.edu/pub/Linux/commercial/]
- DCDFLIB
- A library of C or Fortran routines for computing cumulative
distribution functions, inverses, and other distribution
parameters.
The statistical distributions for which DCDFLIB can
calculate these include
beta, binomial, chi-square, noncentral chi-square,
F, noncentral F, negative binomial, normal, Poisson,
and Student's t.
Given values of all but one parameter of a distribution,
the other is computed.
DCDFLIB is available in either a Fortran or C source code
distribution.
Each routine is documented in comment statements contained
within the source code.
[http://www.netlib.org/random/]
[http://lib.stat.cmu.edu/general/Utexas/
]
- DCE
- The OSF Distributed Computing Environment
is an industry-standard, vendor-neutral set of distributed
computing technologies.
It consists of multiple components which have been integrated
to work closely together: the Remote Procedure Call (RPC),
the Cell and Global Directory Services (CDS and GDS), the
Security Server, DCE Threads, Distributed Time Service (DTS),
and Distributed File Service (DFS). The Threads, RPC, CDS, Security,
and DTS components are referred to as the ``secure core'' and are
the required components of any DCE installation, with DFS
being an optional component. DCE also includes administration
tools to manage the components.
DCE provides security services to protect and control access to
data, name services that make it easy to find distributed
resources, and a highly scalable model for organizing widely
scattered users, services, and data. It runs on all major
platforms and is designed to support distributed applications
in heterogeneous hardware and software environments.
DCE is not intended to exist alone but should be bundled
into an operating system. It is not an application in itself but
can be used to build custom applications. A port to Linux
platforms is being performed by the
DCE-RPC Project.
See Shirley et al. (1994),
Hu (1995),
Peterson (1995), and
Rosenberry et al. (1992).
[http://www.opengroup.org/tech/dce/]
- DCE-RPC
- This is an ongoing project to port
OSF
's
DCE-RPC, a system
for developing portable applications, to Linux.
See Bloomer (1992).
[http://www.aa.net/~mtp/]
- ddcon2d
- A Fortran
code the solves the 2-D Navier-Stokes equations for
Boussinesq convection by Fourier Galerkin/collocation method. The
system models double-diffusive convection where two agents (e.g.
heat and salt) have opposing contributions to the buoyancy and
diffuse at different rates. The code was developed to illustrate
the use of spectral methods to solve a nontrivial hydrodynamics
problem.
[http://sdcd.gsfc.nasa.gov/ESS/exchange/contrib/deane/
ddcon2d.html]
- DDD
- The Data Display Debugger, a GUI
for the popular UNIX debuggers
GDB, DBX and XDB.
Besides the usual front-end features such as viewing
source text, DDD has several other features.
These include:
an interactive graphical data display in which data structures
are displayed as graphs;
debugging programs written in Ada, C, C++, Chill, Fortran, Java,
Modual, and Pascal;
machine-level debugging;
hypertext source navigation and lookup;
breakpoint, backtrace, and history editors;
preference and settings editors;
program execution in a terminal emulator window;
debugging on a remote host; and
a command-line interface with full editing, history and completion
capabilities.
A source code distribution for DDD is available as are binaries
for several platforms.
Compilation requires Motif 1.1 or later or
LessTif 0.83 or later.
A manual is available in PostScript format.
[http://www.cs.tu-bs.de/softech/ddd/]
[ftp://ftp.x.org/contrib/utilities/]
- DDLab
- The Discrete Dynamics Lab is
an interactive graphical program for studying the dynamics of
finite binary networks, a field relevant to studies of
complexity, emergent phenomena, neural networks, and aspects
of theoretical biology.
In DDLab networks can be constructed with any architecture
between regular 1- or 2-D automata and random Boolean networks (i.e. those
with arbitrary connections and heterogeneous rules), with networks
also capable of having heterogeneous neighborhood sizes (from 1 to 9).
Networks can be moved forward in time to display space-time patterns
as well as backwards to generate the predecessors of a pattern
and reconstruct its branching sub-tree of all ancestor patterns.
Sub-trees, basins of attraction, or even the whole basin of attraction
field can be reconstructed and displayed as a directed graph or
set of graphs in real time for smaller networks.
(An attractor basin of a discrete dynamical network is an object
in space-time that links network states according to their transitions,
and it can offer insight into complexity, chaos, and emergent
phenomena in cellular automata.)
Learning and forgetting algorithms allow attaching and detaching
sets of states as predecessors of a given state by automatically
mutating rules or changing connection, a feature which allows sculpting
the basin of attraction field to approach a desired scheme
of hierarchical categorization.
Most network and graphics parameters can be flexibly set, reviewed
and altered (even on the fly).
DDLab allows various quantitative, statistical, and analytical
measures and data to be collected in both forward dynamics and
backwards attractor basin topology modes of operation.
These measures and data include:
the P and Z parameters;
the frequency of canalyzing ``genes'' and inputs;
various measures on forward dynamics such as pattern density,
frozen islands, pattern differences between two networks, the
Derrida plot, rule-table lookup frequency and entropy, and the
variance of the entropy;
various global measures on the topology of attractor basins
including garden of Eden density and a histogram of in-degree frequency;
and a scatterplot of state space.
Binary versions of DDLab are available for MS-DOS, Sun SunOS,
and Linux Intel platforms.
A user's manual is available in HTML format.
See Wuensche and Lesser (1992).
[http://www.santafe.edu/~wuensch/ddlab.html]
- DDRIV
- A routine for solving ODE IVPs.
See CDRIV.
- DDSCAT
- A package to calculate scattering and absorption of
electromagnetic waves by targets with arbitrary geometries using
the discrete dipole approximation (DDA) wherein the target is
replaced by an array of point dipoles. The source code, written
in Fortran, is available.
The documentation is contained within a 38 page user's manual
in PostScript format.
[ftp://astro.princeton.edu/draine/scat/ddscat/]
- debuggers
- Available debuggers and related software include:
- DDD, a GUI for several command-line debuggers
including GDB;
- deet, an extensible graphical debugger;
- dmalloc, a debugging malloc library;
- Duel, a high-level C debugging language
extension to GDB;
- gdbtk, a GUI for GDB;
- LCLint, a tool for statically checking
C programs;
- Nana, a library providing support for assertion
checking and loggin in C and C++;
- SmartGDB, a scriptable and thread-aware
extension to GDB;
- ups, a debugger with an integrated C
interpreter; and
- xxgdb, an X11 front-end to
GDB.
- deet
- A graphical debugger which can be easily retargeted for different
languages, compilers, and operating systems.
This is done by separating the core debugger functionality from
the user interface, with the former implemented with a small
set of commands called a nub (with nubs for Java and C available).
This works on top of GDB and
also requires Tcl/Tk 4.0 and higher.
A source code distribution is available.
[http://www.cs.princeton.edu/~jlk/deet/]
- DejaGnu
- This is a framework for testing other programs whose purpose is
to provide a single front-end for all tests. Its features
include: a flexible and consistent framework which make it
easy to write tests for any program, a layer of abstraction
which allows tests to be written that are portable to any host
or target where a program must be tested, and the same output
format for all tests which makes it easy to integrate testing
into other software development processes.
DejaGnu is a GNU project program written
in Expect, which is in turn written
in Tcl/Tk. The distribution includes
the source code written in Expect and a user's guide in
Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
- Delila
- A package for the information analysis of protein and nucleic acid
sequences.
The programs include:
- alist, creates an aligned listing of sets of sequences;
- alword, prepares an aligned set of protein sequences for
input into concensus;
- aran, generates random sequences from a given sequence;
- asciidna, draws a spiral DNA in ASCII characters;
- binfra, a genetic algorithm
to maximize the fractal dimensionality of a binary string;
- calc, an error-propagating calculator;
- calhnb, calculates the sampling error and variance given a
genomic composition and a series of integers representing the number
of sample sites;
- cerf, calculates the complement of the error function;
- chaos, searches for a chaotic relationship using the potential
locations of binding sites;
- compan, computes chi squared from a composition;
- da3d, shows the position to position correlation data in three
dimensions;
- dangles, calculates the DNA angles of a list of positions;
- dbmutate, mutates GenBank database sequences;
- delila, a database manager for nucleic acid sequences;
- diana, performs dinucleotide analysis of an aligned book;
- dirgra, performs a Monte Carlo analysis of a directed graph;
- dnag, generates a graph of DNA;
- dnamwt, calculates the weight of a DNA molecule;
- encfrq, performs encoded sequence frequency analysis;
- fradna, computes the fractal structure of DNA;
- helix, find helices between sequences in two books;
- hist, make a histogram of aligned sequences;
- lig, computes the results of a ligation reaction for insertion
of a linker onto both ends of a linearized plasmid;
- malopt, creates a 2-D plot of optimal alignments;
- migrate, shows evolutionary selection in the context of a
drunkard's walk;
- patana, does simple analyses of a pattern matrix;
- patval, performs pattern evaluations of aligned sequences;
- sites, gathers, collates, and analyzes data from a
randomization experiment;
and over a hundred more programs.
A source code distribution is available. Each program is written in
C and documented in a separate man page.
[http://www-lmmb.ncifcrf.gov/~toms/delila.html]
- Delta Toolbox
- A Matlab toolbox which provides an extensive collection of
routines for use by a control or systems engineer. The routines
allow control systems to be modeled as transfer functions or in
state space form as well as methods to convert between the various
model representations. The toolbox provides time response,
frequency response, pole-placement, optimal control, and estimation.
The Delta Toolbox differs
from the Control System Toolbox supplied in the standard
Matlab distribution in that while the latter uses the shift
operator for discrete time systems the former uses the delta
operator which has been shown to be superior for such applications.
The delta operator unifies continuous and discrete time theory
such that discrete time results converge to the corresponding
continuous time results as the sampling period is decreased.
It also provides superior numerical properties.
The Delta Toolbox should be seen as an upgrade to the Control
System Toolbox using the delta operator such that each pair of
(continuous and discrete) existing routines is replaced by one using
the delta operator.
The Delta Toolbox can be used with Matlab or with the
freely available Octave package which
can run most Matlab m-files.
It is documented in a 34 page user's manual
in PostScript format.
[ftp://ftp.mathworks.com/pub/contrib/v4/control/]
- Delve
- The Data for Evaluating Learning in
Valid Experiments is a standardized environment
designed to evaluate the performance of methods which learn
relationships based primarily on empirical data, e.g.
neural nets. Delve makes it possible for users to compare
their learning methods with other methods on many datasets,
with the learning methods and evaluation procedures well-documented
so meaningful comparisons can be made. Delve
consists of a software environment, a number of datasets,
and a repository of learning methods.
The software environment consists of a suite of utilities for
manipulating datasets and evaluating method performance. These
utilities allow users to get information about the Delve datasets
installed on their system, get information about which methods
have been run on those datasets, extract training and testing
cases from the dataset file so another method can be run on it,
calculate losses given the predictions a method makes for the
testing data, and calculate summary statistics about the method's
performance and comparie it to other methods.
The learning methods available include linear least squares
regression, multilayer perceptron ensembles, multivariate adaptive
regression splines (MARS), K-nearest neighbors, and more.
The source code for the Delve software environment is available
and can be installed on most generic UNIX platforms which already
have Tcl version 7.3 installed.
The package is documented in a user's manual available in
PostScript format.
[http://www.cs.utoronto.ca/~delve/]
- DEM Tools
- A set of tools for working with Digital Elevation Model (DEM) data.
DEM Tools can be used for previewing DEM data sets and for wandering
around in virtual representations of landscapes.
The tools in the package are:
- dem2ppm, which converts DEM files into PPM format images;
- dem3dmap, a 3-D map viewer which allows images to be
rotated, zoomed and manipulated in various other ways; and
- dem2vrml, which converts DEM files into VRML files.
A source code distribution is available as are static binaries
for Linux Intel platforms.
Building from source requires the Mesa and
GLUT libraries.
[http://www.arq.net/~kasten/demtools/]
- Demeter
- An object oriented software development method featuring a
graphical description of class structures and a high level
language for the definition of object behavior.
Demeter is a software design and development method for
deriving object-oriented
software from informal specifications such as use cases or scenarios.
The software is described at the adaptive object-oriented level rather
than at the object oriented level, with adaptive meaning that it
adjusts automatically to a large number of context changes.
The Demeter software provides a high-level interface to
both C++ and Java.
It defines a high-level interface for defining the structure of
classes and objects through class dictionaries, and also defines
an interface for defining the behavior of objects through adaptive
programs.
The method is supported by a suite of tools including a
graphical user interface (GUI), a consistency checker, C++ code
generators, and a rum-time library of generic software.
Implementations of Demeter are available for Sun SunOS,
IBM AIX, and Linux Intel platforms.
The documentation is in a separate file which
contains a tutorial, several code examples, and a user's
guide in PostScript format.
See Lieberherr (1996).
[http://www.ccs.neu.edu/home/lieber/demeter.html]
- DEMOCRITOS
- A C++ class library specially written to provide support for
tasks in bioinformatics and computational chemistry.
This is currently (6/97) still under development and has
its classes divided into four groups: main, PDB, CIF,
and container classes.
The main group contains over 60 classes including:
DMAtomType, for atom types and associated properties;
DMChemicalElement, for elements and associated properties;
DMAminoAcid, for amino acids and associated information;
DMBivariate, which performs various statistical calculation;
and many more.
A beta version of this is available, although the documentation
is still a bit scarce.
[http://www.seqnet.dl.ac.uk/CBMT/democ/HOME.html]
- DEPAK
- A suite of Fortran 77 programs for the
solution of initial value problems for ODEs.
The package consists of three routines:
DERKF, which uses a Runge-Kutta method;
DEABM, which uses an Adams predictor-corrector method; and
DEBDF, which uses a Gear stiff method.
DERKF is a fifth-order Runge-Kutta code and the simplest of
the codes both algorithmically and in its use.
It is designed to solve non-stiff and mildly stiff DEs when derivative
evaluations are not expensive and should not be used to obtain
high accuracy results or answers at many specific points.
It also attempts to discover when it is not suitable for the assigned task.
DEABM is a variable order (one through twelve) Adams code
of intermediate complexity which is designed to solve non-stiff and
mildly stiff DEs when derivative evaluations are expensive, high
accuracy results are needed, or answers at many specific points
are required. It also attempts to discover when it is unsuitable
for its assigned task.
DEBDF is a variable order (one through five) backward
differentiation formula code. It is the most complex code and
primarily designed to solve stiff DEs at crude to moderate
tolerances. It is much more efficient than the other codes if
the problem is very stiff.
DEPAK is available as Fortran source code. Each of the
three components are documented in comment statements contained
with the source code.
This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
- Depot
- A software management tool that provides a simple yet flexible mechanism
for maintaining third party and locally developed software in large,
heterogeneous computing environments.
It uses an object-oreinted approach to managing software with each
package managed as one or more logical objects.
Depot integrates separately maintained software packages (known as
collections) into a common directory hierarchy consisting of a union
of all of the collections, with this directory defined as the
software environment. A set of configuration options manages
interactions and intersections between collections in the
environment.
A source code distribution of Depot is available. It is written
in C and can be compiled on most UNIX platforms. Several
technical papers are available as documentation.
[http://andrew2.andrew.cmu.edu/depot/depot.html]
- Depot4
- A system for implementing language processors in which translators and
interpreters can be written in the Ml4 language, an extension of the
EBNF form, and then produce an executable program.
Depot4 was created to provide a tool for domain specific language
implementors.
There are version of Depot4 available for
Oberon and
Java.
[http://www.math.tu-dresden.de/wir/depot4/Depot4.html]
- Deskware COBOL
- A compact and easy to use COBOL interpreter which implements some
useful new language features.
This is at present (8/97) in the alpha test stage with
binaries
available for Linux, MS-DOS, Win32, Sun SunOS and Solaris,
and IBM AIX platforms.
[http://www.deskware.com/cobol/cobol.htm]
- device drivers
- See Rubini (1997).
- DFN-RPC
- A remote procedure call (RPC) tool developed for
distributing and parallelizing scientific application programs on
clusters of workstations. It is optimized for applications written
in Fortran but can also be used in a
C environment.
The features of DFN-RPC include:
- synchronous, asynchronous and parallel RPCs;
- datapipes for message passing;
- a central location for handling the completion of a parallel RPC,
the receipt of a datapipe message, an X event, an input, or another
event on a UNIX file descriptor;
- quick start routines for building a network of parallel application
processes;
- a graphical monitor with a step mode;
- a remote file access library;
- routines for establishing a freely configurable interconnection
network between all server processes; and
- several example applications.
A source code distribution of DFN-RPC is available. Versions after
1.0.49alpha will work on Linux platforms, although version 1.0.60beta
is recommended. A user's guide is available as are several technical
reports concerning its development and applications.
[ftp://ftp.uni-stuttgart.de/pub/rus/dfn_rpc/README_dfnrpc.html]
- DGENESIS
- A distributed implementation of parallel genetic algorithms (GA).
Distributed GENESIS is based on the
GENESIS GA package.
This package parallelizes a GA by dividing the population
into subpopulations, runs a conventional GA in each
subpopulation, and allows the periodic communication of
information between subpopulations that helps in the search
for the solution.
The information usually exchanged is a subset of the fittest
individuals of each subpopulation in a process known as
migration.
Each subpopulation is handled by UNIX process and interprocess
communication is handled via Berkeley sockets.
It uses rsh and rcp to execute remote processes
and to copy files across the network.
The source code for DGENESIS is available. It is
written in C and can be compiled and used on UNIX systems
with the above capabilities and programs.
It is documented is a user's manual available in
PostScript format.
[http://www.aic.nrl.navy.mil/galist/src/]
- DHCP
- The Dynamic Host Configuration Protocol
provides a framework for passing configuration information to
hosts on a TCP/IP network. It is
based on the Bootstrap Protocol (BOOTP) but also adds the
capability of automatic allocation of reusable network addresses
and additional configuration options.
It consists of two components: a protocol for delivering host-specific
configuration parameters form a DHCP server to a host, and a
mechanism for the allocation of netowrk addresses to hosts.
DHCP is built on a client-server model where designated DHCP server
hosts allocated network addresses and deliver configuration
parameters to dynamically configured hosts.
The general design goals for DHCP include that:
- it should be a mechanism rather than a policy;
- clients should require no manual configuration;
- networks should require no manual configuration for
individual clients;
- it should not require a server on each subnet;
- a client should be prepared to receive multiple responses to
a request for configuration parameters;
- it must coexist with statically configured, non-participating
hosts and with existing network protocol implementations;
- it must interoperate with the BOOTP relay agent behavior; and
- it must provide serve to existing BOOTP clients.
The given address is for a reference implemtation of DHCP
which contains a server, a client, and a relay agent.
The tools all use a modular API designed to be sufficiently
general to work on POSIX-compliant
operating systems as well as on non-POSIX systems.
The implementation aims to provide full support for all
the intricacies of the protocol as well as to provide
a modular and highly adaptable interface to related tools
such as DNS and NIS.
The dhcpcd package implements the
DHCP protocol.
[http://www.isc.org/dhcp.html]
- dhcpcd
- An RFC-2131 compliant DHCP client
daemon which recieves an IP
address and other information from a corresponding
DHPC server, automatically configures the network interface, and
tries to renew the lease time according to the protocol.
It has been found to work with several servers.
A source code distribution is available.
[http://vukovar.veus.hr/linux/DHCP.html]
[http://sunsite.unc.edu/pub/Linux/system/Network/daemons/
]
- diald
- The dial daemon software makes it appear that you
have a 24 hour a day connection to the Internet over a
SLIP or PPP link.
It can handle tasks ranging from actually keeping a link up for
24 hours a day during phone line problems to dialing out with
a modem whenever a connection is needed and hanging up when
it is no longer needed.
The main function of diald is to provide a proxy network device
that stands in for the physical connection to a remote site. It
monitors the packets sent to the proxy device and tries to bring
up a real link whenever one is needed.
One the real link is in place packets are routed through this
rather than the proxy and the network connection behaves exactly
as if it had been manually established.
The functionality of diald includes:
forcing connections up or down at specified times (including forcing
a continuous connection);
bringing connections up or down based on the flow of traffic across
a network with the possibility of treating traffic differently
depending on the contents of the packet header;
the capability of running multiple copies of diald simultaneously
for connectivity with multiple remote sites;
manual intervention to bring a link up or down, temporarily block it,
or force it to stay up;
allowing incoming connections to, for example, construct a two-way
demand dialed link with a remote site where either can call the
other when a link is needed; and
keepin track of phone usage statistics such as total connect
time for each session and the amount of traffic passed.
A source code distribution of diald is available.
It needs SLIP devices in the kernel to work under all circumstances
and PPP devices for using PPP.
A makefile is supplied which will compile it on most platforms.
A series of man pages are supplied in multiple formats.
[http://www.dna.lth.se/~erics/diald.html]
- Diehard
- A battery of tests for random number generators.
[http://stat.fsu.edu/~geo/diehard.html]
- DIERCKX/FITPACK
- A package of Fortran subroutines for calculating smoothing
splines and tensor product splines
for various kinds of data and geometries with automatic
knot selection. There is another library called
FITPACK which led to the slightly
bulkier name of this one.
The routines also feature error smoothing and data reduction,
with the user supplying a single smoothing factor to control
the tradeoff between closeness of fit and smoothness of fit.
There are programs for
curve fitting over and interval;
fitting a bivariate spline function to a set of scattered data
on a rectangular domain;
smoothing periodic functions, parameteric curves and surfaces,
functions with convexity constraints, data over the sphere,
and other non-rectangular approximation domains.
Very efficient routines are provided for applications with data
given either on a rectangular, polar, or spherical grid.
There are utility routines for the evaluation, differentiation, and
integration of the spline approximations as well as an insertion
algorithm and routines for calculating zeros and Fourier coefficients
of cubic splines.
A source code distribution of DIERCKX/FITPACK is availble.
The routines are all written in Fortran 77 and documented
via comment statements included in the source code files.
The package and the theory behind it are extensively documented in
Dierckx (1993).
[http://www.netlib.org/dierckx/index.html]
- DIFEX1
- An explicit extrapolation integrator for non-stiff systems
of ordinary differential equations based on an
explicit mid-point discretization algorithm.
This is written in Fortran 77 and documented via comment
statements in the source code.
This is part of CodeLib.
See Deuflhard (1983).
[ftp://elib.zib.de/pub/elib/codelib/difex1/]
- DIFEX2
- An explicit extrapolation integrator for non-stiff systems of
second-order differential equations with the first derivative
absent in the right-hand side (based on Stoermer
discretization).
This is a version adapted for possibly calling the multiple
shooting code BVPSOL.
This is written in Fortran 77 and documented via comment
statements in the source code.
This is part of CodeLib.
See Deuflhard (1983).
[ftp://elib.zib.de/pub/elib/codelib/difex2/]
- DIFEXM
- An explicit extrapolation integrator for non-stiff systems of
second-order differential equations with the first derivative
present in the right-hand side in the special form
f(t,y(t)) + L(t,y(t))*y'(t) where L is a diagonal matrix.
This is based on a modified Stoermer discretization.
It is written in Fortran 77 and documented via comment
statements in the source code.
This is part of CodeLib.
See Deuflhard (1983).
[ftp://elib.zib.de/pub/elib/codelib/difexm/]
- differential equations
- Software for solving ordinary or partial differential equations includes:
- CDRIV, Fortran routines for solving ODE
initial value problems;
- CodeLib, a collection of codes for solving
single or systems of differential and/or algebraic equations;
- CODE++, a collection of C++
libraries for ODEs and related problems;
- COLNEW, for solving ODE boundary value problems
using the collocation method;
- CONTENT, a package for the exploration of
dynamical systems;
- CONTIN, an implementation of a continuation
algorithm with an adaptive choice of a local coordinate system;
- COST, a tool for the simulation of coupled
systems of identical oscillators;
- DASSL, a Fortran package for solving systems
of differential-algebraic equations;
- DEPAK, Fortran programs for solving ODE initial
value problems using Runge-Kutta, Adams predictor-corrector, and Gear
stiff methods;
- DIFEX1, an integrator for non-stiff systems
of ODEs based on an explicit mid-point discretization algorithm;
- DIFEX2, an integrator for non-stiff systems
of second-order ODEs;
- DIFEXM, an integrator for non-stiff systems
of second-order ODEs with a special form of the derivative;
- Diffpack, a collection of C++ classes for
the numerical solution of PDEs;
- DOUG, a parallel iterative solver for finite
element systems arising from elliptic PDEs;
- Euler, a numerical laboratory with DE solvers;
- EULEX, an integrator for non-stiff systems
of first-ordr ODEs;
- EULSIM, an integrator for stiff systems of
ODEs based on semi-implicit Euler discretization with h-extrapolation;
- FEAT, a system for solving PDEs using the
finite element method;
- FreeFEM, a system for solving 2-D PDEs
using the finite element method;
- GELDA, a solver for linear differential-algebraic
equations with variable coefficients of arbitrary index;
- Godess, a generic ODE solver system written
in C++;
- HOMPACK, Fortran subroutines for solving
nonlinear systems of equations via homotopy methods;
- KEPLEX, an explicit extrapolation integrator
for non-stiff second-order ODEs;
- LARKIN, a package for the simulation of large
DE systems arising in chemical reaction kinetics;
- LIMEX, a Fortran program for the solution
of linearly implicit differential-algebraic systems using extrapolation
techniques;
- LIMEXS, a Fortran program for solving
linearly implicit differential-algebraic systems using extrapolation and
sparse linear algebra techniques;
- Madpack5,
- MANPACK,
- MCSim,
- MEBDFDAE,
- METAN,
- MEXX,
- MGGHAT,
- Octave,
- ODEPACK,
- PDELIB,
- PERHOM,
- PERIOD-ODE,
- PETSc,
- PLTMG,
- RKSUITE,
- SCNN,
- Tela,
- TIDE,
- UG,
- Xphased, and
- XPP-Aut.
- Diffpack
- A collection of C++ object-oriented class libraries designed for
the numerical solution of partial differential equations. The
package also includes several UNIX utilities for general software
management and numerical programming. The goal of Diffpack is to
provide an environment for the rapid prototyping of simulators
based on PDEs which also offers a high level of efficiency.
The Diffpack libraries are organized into several layers including:
- BasicTools, a set of non-numerical utilities for such
tasks as memory handling, basic array structures, a menu
system, and generic I/O;
- LaTools, class hierarchies for the representation of
different vector and matrix formats as well as linear algebra
tools such as direct and indirect solvers;
- DpKernel, the basic building blocks for finite element
programming tasks such as the representation of grids, fields,
element types, and numerical integration; and
- DpUtil, high-level utilities for finite element programming
including preprocessors, bandwidth reduction tools, filters for
visualization programs, and interfaces to lower level classes.
The source code for
Diffpack is written in C++ and has been successfully compiled
on HP-UX, SGI IRIX, Sun Solaris and SunOS, IBM RS6000,
DEC Alpha, and Linux Intel platforms (the latter using both
g++ 2.6.3 and 2.7.0). Extensive installation instructions are
available both onsite and in the documentation.
Everything from beginning tutorials to advanced programming
manuals is available in PostScript format.
See Arge et al. (1997).
[http://www.nobjects.com/Diffpack/]
[ftp://netlib.att.com/netlib/diffpack/index.html]
- diffutils
- A set of GNU utilities for comparing
and merging files.
The utilities include:
- diff, which shows differences between two files,
outputting differences line by line in any of several formats
which are selectable via command line option;
- cmp, which shows the offsets and line numbers
where two files differ, and can also show all the characters
that differ between the two files, side by side;
- diff3, which shows differences among three files
and can produce a merged file containing the changes made in
two additional versions of an original file, along with warnings
about possible conflicts; and
- sdiff, a command to interactively merge
two files.
These programs are all supersets of standard
UNIX utilities of
the same name, and are usually faster.
A source code distribution of diffutils is available. It
is written in C and can be compiled and installed on many
systems via the autoconfig files
supplied in the distribution.
It is documented in a user's guide included in
Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
- DIME
- The Distributed Irregular Mesh
Environment is a programming
environment for creating unstructured triangular meshes and
doing calculations on the mesh. It can be run interactively
or in batch mode. There are functions in the library for adaptively
refining the mesh, contouring, arrow plots, and other graphics.
The source code is available which is said to run on UNIX
workstations with the X Window system.
[http://www.cacr.caltech.edu/resources/paralib]
- DING
- A newsreader for
Emacs whose name has been changed to
Gnus.
- DIPC
- A package to create a multi-computer system from Linux computers
on a TCP/IP network which facilitates quick and easy data
exchanges and process synchronizations. It uses the processor's
MMU to provide DSM capabilities and provides parallelism at
the program level. The programmer is responsible for invoking
remote programs and there is some support for heterogeneous
environments.
The DIPC package is written in ANSI C and can be compiled and
installed on Linux Intel platforms.
It is documented in several ASCII text files.
[http://wallybox.cei.net/dipc/]
- DIPSO
- A Starlink Project package
is a plotting package incorporating some basic astronomical
applications.
DIPSO was designed to make simple things simple and also to
make complicated things possible. It accomplishes the latter
by providing a number of rudimentary functions and free
parameters, a macro facility for the convenient execution
of regularly used sequences, and a simple Fortran interface
to permit the integration of external software.
The latter capability has led to the inclusion of several
codes for carrying out elaborate calculations like profile
fitting, Fourier analysis, and nebular continuum modeling.
DIPSO is a monolithic program with features to accomplish
nearly anything you might want to do.
The features of DIPSO include:
- hypertext documentation and help,
- a shell command which allows system commands to be executed
from within DIPSO,
- accessing standard Starlink NDF or native DIPSO files,
- command line recall and editing,
- a suite of routines called Emission Line Fitting (ELF) designed to
fit a variety of line profiles to observed data, and
- almost 200 command line commands to perform a multitude of tasks.
These tasks include calculating black-body fluxes, selecting graphics
devices, de-reddening data, error estimation, filtering high
frequency components from a Fourier transform, taking Fourier transforms,
controlling all features of the graph being constructed,
re-gridding arrays onto regular grids,
creating a theoretical absorption profile for an interstellar cloud,
applying ageing corrections for IUE cameras,
finding various statistical quantities,
applying Gaussian smoothing to an array,
converting data units, finding maxima and minima,
and much more.
A binary version of the DIPSO package is available for
Linux Intel, DEC OSF/1, and Sun Solaris platforms.
It is documented in a 58 page user's guide available in
PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
[http://axp2.ast.man.ac.uk:8000/~dsb/dipso/dipso.html
]
- DIRECT
- A program that calculates the gravitational acceleration and
potential for all particles output by a separate N-body
simulation using the direct method.
DIRECT is designed to test the results generated by more
complicated gravity codes such as Barnes-Hut, Fast Multipole,
error-controlling tree, and FFT codes. It is also the preferred
overall method for simulations with les than 10,000 particles.
It uses no approximations in its calculation of the
gravitational interactions and simply sums over all pairwise
interactions, scaling as O(N2) in CPU time.
DIRECT supports three softening methods: uniform
density sphere, plummer, and cubic spline softening.
It also supports periodic boundary conditions using the
Ewald summation technique to handle the effect of periodic
boundaries on gravitational interactions.
The source code for DIRECT is available. It is written in
ANSI C and should compile and be usable on most generic
UNIX platforms.
It is documented in a man page.
DIRECT is part of the
HPCCSOFT Tools suite.
[http://www-hpcc.astro.washington.edu/tools/DIRECT/]
- DIRT
- The Design In Real Time
X Window user interface builder
allows the interactive
creation and rapid prototyping of X user interfaces using the X Toolkit and a
number of other Widget sets. User interfaces are created interactively via
the direct manipulation of user interface objects, i.e. widgets, such as
push-buttons, menus, and scroll bars. The look and feel of each widget is
controlled by attributes that can be modified interactively. Objects can be
used as soon as they are created, and Dirt generates the source code
required for the designed user interface and separates the user interface
definition from the application code.
The object classes available in Dirt are the Athena Widget Set (Xaw), the
standard set for the Xt Toolkit, and the UKC Widget Set, a smaller set of
widgets that were mainly created for Dirt but can be used across a wide
selection of user interfaces. A lot of these are extensions of the Athena
Widget Set. The additoin of new widget classes is a straightforward
procedure.
This should compile on generic UNIX/X Windows systems since the
aforementioned widget sets are included in the standard X distribution. A 36
page PostScript user guide is available as well as another more technical
document describing the implementation of DIRT and how to add new
objects to the system.
[ftp://ftp.ukc.ac.uk/pub/rlh/src/X/dirt/]]
- DISCERN
- A large and modular neural network system for reading, paraphrasing,
and answering questions about stereotypical (script-based) stories.
DISCERN is a complete natural language processing (NLP) system implemented
entirely at the subsymbolic level in which distributed neural
network models of parsing, generating, reasoning, lexical processing,
and episodic memory are integrated into a single system that
learns to read, paraphrase, and answer questions about narratives.
DISCERN was constructed as an example of a general approach to
building high-level cognitive models from distributed neural
networks which serves as a plausible model of isolated cognitive
phenomena and has sufficient constituents for generating complex,
high-level behavior.
The DISCERN package consists of four components.
- PROC contains the code and data for training and testing
the story processing modules of the system. It is trained to
read and paraphrase script-based stories and answer questions
about them. It can also be used without the system as a starting
point for various experiments in modular connectionist NLP
architectures.
- HFM contains the code and data for training and testing
the HFM memory organization and hierarchical classification
model. It consists of a pyramid of feature maps that self-organize
according to the hierarchical taxonomy of the data and was
developed as the episodic memory organization for the system.
It can also be used separately for experiments in connectionist
cognitive architectures as it includes code for self-organizing
feature maps and general routines for managing the simulation,
collection statistics, and visualizing the feature maps.
- DISLEX is for training and testing the DISLEX model of
the lexicon, and consists of two feature maps (one of lexical
symbols and the other of word meanings) and the associated connections
between them that translate between symbols and meanings.
It includes code for self-organizing feature maps and Hebbian
association connections that form many-to-many mappings between maps
that can also be used separately.
- DISCERN is for running the complete, trained system and
consists of code which links together into a single, large model
the various subcomponents. It contains routines for simulation
management, statistical collection, system visualization, and
interacting with the system via command-line and GUI interfaces.
Source code distributions of each of the four components which
comprise DISCERN are available. All code is written in C
with the GUI developed using the standard X11 libraries
for enhanced portability.
The system is completely documented in Miikkulainen (1994),
although shorter descriptions can be found in various technical
papers and reports avaiable at the site.
[http://www.cs.utexas.edu/users/nn/pages/software/software.html]
- DISLIN
- A high-level library of subroutines and functions that
display data graphically. It is intended to be a powerful
and easy to use software package for programmers and scientists
which does not require knowledge of any hardware features.
DISLIN can be used with C, Fortran 77, and Fortran 90.
The features of DISLIN include:
- nine fonts with six alphabets in each font;
- plotting 2- and 3-D graphs where the axes can be linear or logarithmic
and labeled with several formats;
- plotting of several curves simultaneously and modification of
curve features;
- legend plotting;
- elementary plot routines for lines, vectors, and outlined or
filled regions;
- definition of shield regions;
- business graphics;
- elementary image routines;
- several geographical projections for map plotting;
- contouring;
- a graphical user interface based on Motif; and
- output to HPGL, PostScript, Prescribe, Tektronix, and X Window formats.
The DISLIN library is available for several platforms and
is freely available for Linux Intel platforms.
It will work with gcc, g77, f2c, the Image F, and
the NAG F90.
The package is extensively documented in manuals available
in PostScript format.
[http://www.mpae.gwdg.de/dislin/dislin.html]
[http://sunsite.unc.edu/pub/Linux/apps/graphics/
]
- DISORT
- The DIScrete Ordinates Radiative Transfer
package is a Fortran 77 program for computing quantities related
to radiative transfer in a multi-layered plane-parallel medium.
It was designed to be the most general and versatile radiative
transfer program available for this type of situation, applicable
to problems from the ultraviolet to the radar regions of the
electromagnetic spectrum.
The quantities it calculates include:
the direct-beam flux,
difffuse down-flux (total minus direct-beam),
diffuse up-flux,
flux divergence,
mean intensity,
azimuthally-averaged intensity at user specified angles
and levels,
and the albedo and transmissivity of the medium as a function
of incident beam angle cosine.
A source code distribution of DISORT is available.
It is written in Fortran 77 and is documented in a lengthy
ASCII user's guide as well as within the code itself.
A test problem is also available in the same directory.
Read the documentation carefully to avoid common errors in
the usage of DISORT.
[ftp://climate.gsfc.nasa.gov/pub/wiscombe/Discr_Ord/]
[http://climate.gsfc.nasa.gov/~wiscombe/
]
- Distillery
- A PostScript program for taking another
PostScript program and converting it so that it complies with the
Adobe document structuring conventions (DSC).
This allows individual pages to be accessed randomly without
requiring all previous pages to be processed in order to
correctly determine the state of the machine.
Distillery only provides for Level 1 PostScript.
[http://www.cs.adfa.oz.au/~gfreeman/]
- ditroff
- See troff.
- Dive
- The Distributed Interactive
Virtual Environment is
an experimental platform for the development of virtual
environments, user interfaces and applications based on shared
3D sythetic environments. It is especially tuned for
multi-user applications where participants navigate in 3D space
and see, meet and interact with other users and applications.
Dive has a VRML interface
in addition to its own scene description format. Binary versions
are available for SGI, Sun, HP, DEC Alpha and Linux platforms.
[http://www.sics.se/dive/]
- DJGPP
- DJ's GNU Programming Platform is
a port of the GNU C compiler and development tools to a 32-bit,
protected-mode environment on Intel 32-bit CPUs running MS-DOS and
compatible operating systems. DJGPP includes a free 32-bit
DPMI server which allows for a 32-bit, 4 GByte flat address
space and up to 256 MBytes of virtual memory, a compiler
which produces 32-bit protected-mode code, and a suite of GNU
development tools ported to MS-DOS. This provides a development
environment which is especially good for porting UNIX programs
to MS-DOS, although it can also be used to write new code.
DJGPP can be used on Linux platforms via the
DOSEMU emulator software.
There is extensive online documentation on how to use DJGPP.
All of the manuals for the GNU development tools ported to
DJGPP can also be used as documentation for DJGPP.
[http://www.delorie.com/]
- dld
- A GNU library package of C functions which
performs dynamic link editing.
This allows programs that use it to add compiled object code
to or remove such code from a process any time during its
execution. Loading modules, searching libraries, resolving
external references, and allocating storage for global and
static data structures are all performed at run-time.
The dld library supports a.out object types on
c*-convex-bsd*, i386-*-linuxaout*, i386-*-linuxoldld*,
i386-sequent-sysv4*, m68k-*-sunos3*, m68k-*-sunos4*,
sparc-*-sunos4*, and vax-*-ultrix* platforms.
A future version of dld is planned to be able to use the
GNU BFD library to support a much wider range of object
types, including ELF.
A source code distribution of dld is available.
It is written in C and can be compiled and installed
on many platforms via the included configure file.
It is documented in a manual in Texinfo
format as well as in a technical report.
See Ho (1991).
[http://www.gnu.ai.mit.edu/order/ftp.html]
- Dlgedit
- The has been renamed to
Qt Architect.
[http://www.primenet.com/~jtharris/dlgedit/]
- dlint
- A DNS verification utility that can analyze
any regular or in-addr domain, either singularly or recursively,
and give notification of possible problems its sees by printing
errors or warnings.
The dlint utility checks hosts with ``A'' records giving an IP
address but no PTR record pointing from the address back to the
host, in-addr PTR records giving a host domain name which has
no associated ``A'' record, and gives a special warning if it
detects a pound sign on the front of a host name.
It will also notice if there are subdomains and recursively
traverse them looking for problems.
The error and warning messages are informative and suggest
ways to fix the problems that it finds.
A source code distribution of dlint is available.
It requires Perl 5 and dig 2.1 for
installation and use.
It is documented in an ASCII text file.
[http://www.jammed.com/~pbalyoz/dns/]
- dlxlab
- A project which provides a simulation and real-time execution
environment for control system experiments.
Virtually any experiment involving dynamical elements, required
inputs, and generated measurable output can be simulated and
executed using dlxlab.
This system consists of two separate programs:
dlxsim, a program to simulate control systems; and
dlxrun, a program to perform data collection.
The dlxlab system is available as source code or as an ELF
binary for Linux Intel systems.
Compilation requires the XView library.
An extensive 160 page user's manual and tutorial is available
in PostScript format.
[http://jhd486.mast.queensu.ca/~jon/homepage.html]
- dlxrun
- See dlxlab.
- dlxsim
- See dlxlab.
- dmake
- Distributed Make is a generic parallel make utility
designed to speed up the process of compiling large packages.
It was designed for use with DQS but
can also be used as a standalone make utility which can significantly reduce
compilation times for large packages.
The features of dmake include:
- support for portable makefiles,
- portability to many platforms,
- significantly enhanced macro facilities,
- a sophisticated inference algorithm supporting transitive closure on
the inference graph,
- support for traversing the file system both during making of targets
and during inference,
- meta rules for specifying rules to be used for inferring
prerequisites,
- conditional macros,
- proper support for libraries,
- parallel making of targets on platforms which support such things,
- attributed targets,
- text diversions,
- group recipes, and
- high configurability.
A source code distribution is available.
[http://www.scri.fsu.edu/~dwyer/dmake.html]
[ftp://plg.uwaterloo.ca/pub/dmake/
]
- dmalloc
- The debug memory allocation library is a drop-in replacement
for a system's malloc, realloc, calloc, free and
other memory management routines which additionally provides powerful
debugging facilities which are configurable at runtime.
The dmalloc debugging features include:
- providing the file name and line numbers of pieces of bad code;
- facilities to provide return address information to debug calls
to the library from external sources;
- fence-post checking, i.e. checking for code that accesses above
or below an allocation;
- heap-constancy verification to ensure that problems will be
caught faster and better diagnosed;
- a number of logging capabilities for tracking unfreed memory
pointers, runtime memory usage, memory transactions, administrative
actions, and final statistics;
- examining unfreed memory to ensure that freed memory pointers
aren't reused;
- error messages designed to give maximal information to developers; and
- configurability to quit immediately when an error is detected and to
dump a core file or memory image.
A source code distribution of dmalloc is freely available for noncommercial
applications.
It can be compiled and installed on most systems using the usual
GNU tools.
It has been used successfully on many platforms including Linux Intel.
It is documented in Texinfo format.
[http://www.letters.com/dmalloc/]
- DMeroon
- Distributed Meroon is the first layer of a new
distributed language called Icslas.
It provides a data model above a coherently distributed
memory and allows users to statically or dynamically create
new classes hierarchically organized, to instantiate these classes,
and to dynamically and coherently share the resulting instances
over a network. DMeroon automatically takes care of representation
and alignment, migrating and sharing objects, coherence, and local
and global garbage collections.
A partial implementation of DMeroon currently (12/97) exists
which can be operated from either C
or Bigloo.
It is documented in a technical report available in
PostScript format.
[ftp://ftp.inria.fr/INRIA/Projects/icsla/WWW/DMeroon.html]
- DmPack2
- A library of basic C++ classes which
contains various container classes, e.g. bag, dictionary,
multi-dictionary, set, array, etc.
The features of DmPack2 include:
best/worst case complexity for memory usage and speed;
generic algorithms based on run-time information;
streamable objects (i.e. persistence, send/receive via sockets);
use of Remote Method Call (RMC) for distributed objects without
additional programs; and more.
The source code for DmPack2 is available. It is written in
C++ and can be compiled using g++.
The documentation is contained within HTML files included
in the distribution.
DmPack2 is used as the foundation for the
WipeOut integrated development environment.
[http://www.softwarebuero.de/dmpack2-eng.html]
