Next: Dn-Dz Up: Linux Software Encyclopedia Previous: Cn-Cz Contents

Da-Dm

Last checked or modified: Dec. 12, 1999

daemons: Software packages that involve UNIX daemons include:

ACAPd, a daemon implementing an Internet protocol for remote accessing client program options;

AgentD, a modular scheduling daemon;

AgentX, a protocol specifying a method by which subagents can advertise and export MIB regions;

AMD, a daemon that maintains a cache of mounted file systems;

BIND, an Internet name server package;

bpowerd, a power daemon for controlling specific UPS units;

BWNFSD, an RPC daemon used with a client NFS for DOS-based PCs;

Card Services, a PCMCIA support package;

chrony, for maintaining the accuracy of the system clock;

CMU-SNMP, an implementation of SNMP;

daemontools, a set of programs to automate some system tasks;

DBOX, a BBS package with a mailing list daemon;

dhcpcd, a DHCP client daemon;

DSC, an environment for distributed processing;

fetchpop, a POP3 mail client;

genpower, a UPS power daemon;

HPVM, a package for high performance computing on distributed machines;

IMSPD, a server daemon implementing the IMSP protocol suite;

inet6-apps, a collection of IPv6-aware applications;

inetutils, a package of common networking utilities and servers;

JNet, a collection of miscellaneous UNIX commands;

LAM, an MPI programming environment;

lbnamed, a load balancing name server;

Linuxconf, a system administration tool;

Linux Phone Project, a project to use phones over the Internet;

masq, management utilities for a Linux firewall;

masqdialer, a daemon for initiating and terminating dialup connections;

MBone, a protocol for multicasting live audio and video via the Internet;

mEDA-2, an extension to PVM;

MON, an extensible service monitoring network daemon;

MRT, a multi-threaded routing toolkit for building multicast daemons;

NetKit, a collection of basic network tools;

NTP, a network time protocol;

Perfs, a tool for distributing processes among several machines;

PIKT, a package for administering heterogeneous networked workstations;

ProFTPD, an FTP server daemon;

PVM, a library and daemon for message passing;

rapd, a daemon for sending text messages to radio pagers and mobile telephones;

rinetd, a redirection server;

rjobs, a remote periodic job agent/daemon;

Rover, a network management package;

RSVP, a protocol with support for quality of service flows;

rtnppd, a TNPP daemon;

SandiaXTP, an implementation of the XTP protocol;

SANE, a package implementing a universal interface to scanners;

Spread, a toolkit and daemon for providing multicast communications over a network;

sysdaemon, a UNIX system monitor;

Taylor UUCP, a package implementing the UCCP protocol;

TCP_wrappers, a daemon for controlling access to network services;

ud, an uptime daemon;

uptimed, an uptime daemon;

util-linux, a collection of many Linux utilities;

Watchdog, a daemon that checks if a system is working;

watchlogd, a daemon that rotates system logs;

wu-ftpd, an FTP server daemon;

xinetd, a replacement for inetd;

ypserv, an NIS server daemon;

ZedKit, a Z39.50 toolkit;

Zephyr, a notice transport and delivery system;

ZMailer, a mail transport agent; and

Ztalk, a voice communication tool.
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]
D'Agents: A transportable agent system written in an extended version of Tcl. This is implemented as two components: an extended Tcl interpreter and a server that runs on each machine. A source code distribution is available.
[http://www.cs.dartmouth.edu/~agent/]
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/]
Dancer: An IRC robot that supports Danish, Dutch, English, Norwegian and Swedish. The features of Dancer include:

single-channel and highly configurable;

password protection of critical commands;

protection against flooding and channel takeover;

awareness of netsplits;

database of answers to FAQs;

relaying messages between users;

support for Client To Client Protocol (CTCP); and

support for Direct Client to Client Chat (DCC).

A source code distribution of this C program is available and has been successfully compiled on several UNIX flavors including Linux.
[http://www.fts.frontec.se/~dast/dancer/]
dante: A free implementation of a SOCKS v4/v5 client and server. The current (9/99) version implements:

SOCKS protocol version 4;

SOCKS protocol version 5 without GSSAPI as described in RFC 1928;

username and password authentication for SOCKS v5 as described in RFC 1919; and

encryption support using SSL.

The features of Dante include:

a design for both security and scalability;

multi-layer access controls;

enables server applications to be SOCKSified;

capable of SOCKSifying most programs at runtime without recompilation;

allows clients to resolve hostnames through SOCKS V4 servers;

works with TCP wrappers (libwrap); and

experimental msproxy support.

A source code distribution is available under a BSD/CMU-type license.
[http://www.inet.no/dante/]
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 comprehensive audio sample editing and processing suite. DAP features include:

support for AIFF, AIFF-C, RAW and WAV audio files;

support for 8 or 16 bit resolution;

support for 1, 2 or 4 channels of audio data;

full time stretch resampling;

manual data editing; and

a reasonably complete DSP suite.

This is available as either source code or a Linux ELF binary.
[http://www.cee.hw.ac.uk/~richardk/]
DaRT: The Data Retrieval Tool is a Java application used for the simultaneous retrieval of documents and archived scientific instrument data that can be accessed via the Web. The features include:

scheduling downloads for later times;

downloading retries for failed downloads;

downloading the most recent version of documentation;

support for internal host name resolution;

configurable target and destination directories; and

starting the program from the command line or a browser.

[http://monet.astro.uiuc.edu/ADC/DaRT/]
Darwin: An operating system ased on the foundation technologies of the Mac OS X Server. This is an advanced BSD UNIX system with advanced networking, the Apache web server, and support for both Mac and UNIX filesystems. It will run on both Power Mac and Intel x86 architectures. Darwin may develop independently of the Mac OS X, although the two code bases will periodically be synchronized. The entire project consists of both Apple and third party subprojects, with the latter including ports of the GNU utilities. An online form must currently (5/99) be completed to gain free access to the source code.
[http://www.publicsource.apple.com/projects/darwin/]
Darxite: An FTP system consisting of a daemon whose job is to retrieve files and execute other FTP commands, and a number of clients programs whose jobs are to control the daemon and to provide a spiffy user interface. The features of Darxite include:

control and monitoring via client programs that are easy to write for any underlying GUI development environment;

auto-resuming of transfers when possible;

automatic switching to mirror sites if a transfer becomes too slow; and

spooling of transfers.

The clients currently (1/99) included in the package are:

DarxGet, obtains a URL from the command line;

NoctFTP, an FTP client written using GTK;

DarxStat, displays the current transfer status;

DarxStat-GTK, DarxStat in a GTK window;

dxFTP, a command-line FTP client; and

DarxCmd, a low-level utility for sending commands to the daemon.

A source code distribution is available.
[http://www.hell.ukgateway.net/darxite/]
Dash: Note: This project has had its name changed to Dash, so check their for further information. A servlet framework for building secure, dynamic websites. Dash is designed such that development can proceed in Java without having to learn or switch to XML/XSL/XSP or some other template language to obtain the HTML and logic abstractions required by template-based Web applications. It can even be easily integrated with existing WebMacro and FreeMaker websites by creating special screens to parse templates. These screens can also be created to read files from other websites as well as from off disk.
Dash is composed of five different modules that each serve a specific service within the framework and which are each defined in an object-oriented fashion. These are:

an Action module that represents a piece of code that performs a task, e.g. a piece of code to read the contents of a submitted HTML form;

a Page module that is first in the chain of execution for page generation and which contains the remainder of the modules;

a Screen module that is essentially the body of the web page and where the HTML of the page is generated;

a Navigation module with a top and bottom scheme generally defined as the header and footer of the site; and

a Layout module that defines the physical layout of a web page, generally defining the location of the Navigation portion as well as the location of where the body or Screen of the page will be.

Daily snapshots of the Dash development package are available under the LGPL.
[http://www.working-dogs.com/dash/]
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 t to t. 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:

Boulder, a semantic free data interchange format used in the biosciences;

CDF, a self-describing data abstraction for the storage and manipulation of multidimensional data in a discipline-independent format;

CGNS, a format for storing, retrieving and modifying CFD data;

CIF, a standard means of information exchange in crystallography;

DRS, a data retrieval and storage library used mainly for climate model output;

FITS, the format adopted by the astronomical community for data interchange and archival storage;

FlexIO, an API for storing multidimensional data that hides the differences between underlying formats;

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;

IEEEIO, a library for storing multidimensional data in a portable binary format based on IEEE 754;

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;

SDDF, a data description language and an API implementing its specifications;

SDTS, a standard for transferring earth-referenced spatial data between dissimilar computer systems;

SEDRIS, a standard for describing and exchanging environmental data; and

VPF, a standard format and structure for large geographic databases.

[http://www2.echo.lu/oii/en/oiistand.html]
database: Informative sites related to Linux and/or databases include:

Linux SQL Databases and Tools
[http://linas.org/linux/db.html]

Free Database List
[http://www.iam.unibe.ch/~scg/Archive/Software/FreeDB/FreeDB.list.html]

RDBMS List
[http://www.hex.net/~cbbrowne/rdbms.html]

Object-Oriented Databases
[http://www.rhein-neckar.de/~cetus/oo_data_bases.html]

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;

CQL++, an SQL and ISAM database management system;

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;

dbMetrix, an SQL database frontend tool that supports most of the freely available SQL implementations;

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;

FramerD, a portable, distributed, object-oriented database designed to support the maintenance and sharing of knowledge bases;

FreeTDS, a free implementation of the Sybase call level interface library DB-Lib;

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;

libsql++, a C++ library that wraps ODBC calls into an object-oriented interface;

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;

mxODBC, a Python DB compliant interface to ODBC databases;

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;

rdb, a reliable database library based on cdb;

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;

SQL Server, a portable multiuser DBMS;

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;

WIDD, a database GUI front-end written in Java;

WODA, a database written in Perl for creating flat multimedia databases;

Xbase, a library for manipulating Xbase-type data files;

xmbase-grok, a simple database manager and user interface builder; and

XSB, a research-oriented logic programming and deductive database system.

See Bancilhon and Buneman (1990), Castano et al. (1994), Kim (1995) and Whitehorn and Marklyn (1998).
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 can be compiled on most generic UNIX platforms with Fortran and C compilers, 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/]
Data Visualization Toolbox: A Matlab toolbox for data visualization. The programs in this toolbox are for working with and visualzing various types of data:

univariate data including characterizing a distribution, comparing distributions and transforming data;

bivariate data including curve fitting, visualizing residuals, robust fitting, discrete values, time series and seasonal components;

trivariate data including scatterplots, coplots, image plots, surface fitting, contour plots, mesh plots and surface plots;

hypervariate data including scatterplots and color scatterplots; and

multiway data including multiway dot plots, additive fits, and color scatterplots.

[http://www.datatool.com/Dataviz_home.htm]
Datbkr: A multicall, tar-based shell script along with a small program called tarblocks designed to work with partitionable DAT drives for performing backups. The source code is available.
[http://www.psychosis.com/datbkr/]
DAV: Distributed Authoring and Versioning is a protocol specifying how to use HTTP to provide enhanced capabilities to a web server. It is envisioned as a method for authoring pages without proprietary packages. Other planned capabilities include document management, complex configuration management, and many other types of web-based data repositories. It is sometimes called a web-based filesystem augmented with properties for the directories and files. This is also sometimes called WEBDAV.
[http://www.lyra.org/greg/dav.html]
[http://www.ics.uci.edu/pub/ietf/webdav/]
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.
The features of DAVID include:

support for multiple windows and displays;

black and white and color screen support;

a C language-like programming syntax;

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 arrays with hidden line removal, etc.);

interactive graphics animations with movie-like capabilities;

an interactive graphics editor;

an interactive diagnostics system and feature tracking; and

an interactive color map editor and 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://www.sleepycat.com/]

py-bsddb

A Python 1.5.2 interface to Berkeley DB developed using SWIG 1.1.
[http://electricrain.com/greg/python/bsddb3/]
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://www.gnacademy.org/uu-gna/tech/dbedit/dbedit.html]
DBI: The DataBase Interface for Perl 5 is an ongoing effort to design and implement a database-independent interface for database connectivity which abstracts the complexity of database technologies from the programmer. The DBI API specification defines a set of functions, variables and conventions that provide a consistent database interface independent of the actual database being used. The database-dependent code for a wide range of available databases is extracted and placed into database drivers (DBDs). These implement all of the methods defined by DBI API for each specific database and are transparent to the user. A source code distribution is available along with modules for over fifteen different database systems.
[http://www.symbolstone.org/technology/perl/DBI/]

WDBI

The Web DataBase Interface is a Perl program that allows a Web browsers to be used to interact with a database. A browser can be used to search, enter, update and delete data. This uses the DBI package to access the SQL database being used.
[http://www.wdbi.net/]
dbMetrix: An SQL database tool that provides a graphical, modularized front end to various freely available SQL servers. This is being developed with MySQL although it supports several other SQL-based databases. A source code distribution is available which requires GTK for compilation.
[http://www.tamos.net/sw/dbMetrix/]
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 and file boards;

a mailing list daemon and mail file server;

Internet interfaces via POP3 and HTTP/HTML;

a homepage manager for user-designed homepages; and

online shopping with user accounts and customizable logos/images.

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/]
DBS Server: A package that supports the integration of the Panasonic DBS telephone system with UNIX servers via the use of the Panasonic API/TSAPI card and the call control protocol (PAPI) supported by the card. The server consists of an interface daemon supporting the PAPI protocol on a serial port, and it provides shared access to the DBS API resources through a UNIX domain socket. Additional functionality is obtained with other daemons which talk to the interface daemon. The package requires an existing Panasonic DBS telephone sysem equipped with the API card. A source code distribution is available.
[http://www.tycho.com/dbs/]
DBT: A Matlab toolbox for radar array processing. DBT is especially suited for processing in the spatial dimension using signals from an antenna array. The features include:

modeling array antennas with and without beamforming to subarrays;

arbitrary antenna element placements and patterns;

simulation of model errors;

single-range simulation of Gaussian distributed narrowband signals and wideband signals with a Gaussian distribution or a specified time signal;

simulation of narrowband radar signals with specified doppler shifts and waveforms;

a choice of waveforms including rectangular pulses and Barker, Frank and Chirp code;

simulation of exponentially distributed clutter including platform motion;

a wide range of conventional signal processing capabilities;

model based signal processing including estimation and modification of the spatial correlation matrix by four methods, spectral high-resolution DOA estimation by six methods, parametric high-resolution DOA estimatino by eleven methods, etc.;

incoherent integration of radar signals;

special functions for the analysis of radar signals; and

plots of received signals, spatial correlation matrices, etc.

[http://www.s2.chalmers.se/~athley/dbt/]
DB2XML: A Java tool for transforming relational databases into XML. The functions provided are:

transforming the results of database queries into XML documents; and

providing attributes describing characteristics of the data.

This requires JDK 1.1 or above and a database with a JDBC driver.
[http://www.informatik.fh-wiesbaden.de/~turau/DB2XML/]
dcc: A decompiler that decompiles x86 binaries into C programs, with the final program containing assembler code for any subroutines that can't be decompiled at a higher level than that. The dcc program uses traditional compiler optimization techniques to eliminate registers and intermediate instructions to reconstruct high-level statements as well as graph theory to determine the control structures in each subroutine. A source code distribution is available.
[http://www.cs.uq.edu.au/groups/csm/dcc.html]
dcc: The Disciplined C Checker is a code checker for C programs that performs full syntactic and some static semantic analysis. It enforces a set of rules and guidelines for writing C code in a higher-level dialect called Disciplined C. This checker allows/enforces strong naming and typing, well-defined types, name equivalence for all types, reasonable automatic conversion rules, easy to use arrays, limited use of casts, and enhanced structuration, encapsulation and portability. It also removes most of the common pitfalls of C programming.
The features of Disciplined C enforced by the checker include:

checking line indentation against the current block level for detection of missing left/right braces or bad if/loop bodies;

separation of declarations from statements by white lines;

allowing only void type expressions to be used as statements except for expressions whose top operator is an assignment or increment operator and functions whose main effect is a side effect;

requiring that if parameter names are given in function prototypes, the same name must be used for the corresponding parameter in the function definition to ensure that the meaning of the prototype stays the same as the implementation;

not allowing a function name to be a pointer on that function;

requiring pointers on functions to be dereferenced before use;

checking that a switch statement controls a block;

requiring that type attributes must precede qualifiers to clarify the distinction between them;

not allowing pointers on local objects to be returned or assigned to global/external variables;

requiring the naming of of numeric constants except in a few situations;

detection of over- and under-flows in constant expressions;

checking argument types against format string specifications in scanf/printf statements;

external identifiers are checked for non-ambiguity for the local linker;

parenthesis problems with macro bodies are detected;

uninitialized local objects are flagged; and

unused variable values are signalled.

A source code distribution of dcc is available. It is written in ANSI and is configured for several compiler/platform combinations including GCC/Linux. It is documented in a technical report available in PostScript format.
[ftp://ftp.supelec.fr/pub/lang/dcc/]
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/]
[http://www.bu.edu/~jrd/FreeDCE/dce11rpc.html]
DCSE: The Dedicated Comparative Sequence Editor is a multiple alignment editor that can be used to edit protein, DNA or RNA alignments and that an incorporate the structures of the molecules in the alignment. Additional features include color display of characters and structure, automatic alignment relative to sequences already aligned with others, sequence grouping, sequence or pattern searching, a marker system and checking of the incorporated RNA structure. Binary distributions for X11 built using Tcl/Tk are available for Linux and other platforms.
[http://www-rrna.uia.ac.be/dcse/]
[ftp://ftp.bmc.uu.se/pub/linnaeus/software/dcse/]
DCUHRE: A Fortran 77 package implementing an adaptive multidimensional integration routine for a vector of integrals. This is TOMS algorithm 698 and is documented in Berntsen et al. (1991a) and Berntsen et al. (1991b).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
DCUTRI: An adaptive algorithm for computing an approximation to the integral of each element in a vector function o.ver a 2-D region made up of triangles. The basic cubature rule used over each triangle is a 37-point symmetric rule of degree 13. The local error for each element in the approximation vector and for each triangle is computed (on the same evaluation points) using a sequence of null rule evaluations. A sophisticated error-estimation procedure attempts to decide whether there is asymptotic behavior locally for each function, with different actions taken based on that decision. This is TOMS algorithm 706 and is documented in Berntsen and Espelid (1992).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
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 including:

an interactive graphical data display in which data structures are displayed as graphs;

debugging programs written in Ada, C, C++, Chill, Fortran, Java, Modula, 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/]
DDG: The Digital Dawn Graphics toolkit is a library of C++ classes for building real-time 3-D graphics applications. This uses OpenGL and GLUT (and works with sf Mesa), i.e. use of these classes totally shields you from dealing with OpenGL specifics.
Some of the nearly 100 classes include:

2-, 3-, and 4-D vector and matrix classes;

a class for min/max interpolation;

a string class for pure C++ string operations;

an error handling infrastructure;

a clock to measure time;

a multiple viewport class that supports keyboard and mouse;

a parameter class to control object parameters bound to keys;

camera classes to view the same scene from different perspectives;

classes for scaling, translating and rotating;

color and color group classes;

material, light, light model and fog classes;

a text class for rendering text;

texture classes which can read/write RGB, TGA and z-buffers;

generic objects, e.g. box, cylinder, axis, grd, lattice, etc.; and

a geodesic object to create faceted spheres.

[http://www.oz.net/~ddg/]
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/]
deal.II: A C++ program library for adaptive finite elements and error estimation. The primary development goal is to implement modern finite element algorithms in 1-, 2- and 3-D using sophisticated error estimators and adaptive meshes. The features include:

a unified interface that enables writing programs in an almost dimension-free manner;

locally refined grids including different adaptive refinement strategies based on local error indicators and estimators;

a wide variety of finite elements including Lagrange elements of order one through four and discontinuous elements;

extensive documentation including 200 pages of tutorials and over 1000 pages of programming interface information;

use of modern object-oriented software engineering techniques to make access to complex data structures and algorithms as transparent and simple as possible;

fast algorithms for solving problems with even millions of degrees of freedom quickly; and

several available output formats including some commonly used for scientific data visualization.

The source code is available under an open source license.
[http://gaia.iwr.uni-heidelberg.de/~deal/]
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;

GDB, the GNU debugger;

gdbtk, a GUI for GDB;

KDbg, a GUI for GDB;

LCLint, a tool for statically checking C programs;

ldb, a retargetable debugger for ANSI C;

Nana, a library providing support for assertion checking and loggin in C and C++;

Pydb, a version of the standard Python debugger for making it usable with DDD;

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.

[http://www.ptools.org/hpdf/]
[http://www.cs.nmsu.edu/~mikau/aadebug.html]
DECnet: The Linux DECnet Project aims to write a network protocol for Linux that will allow it to communicate with DECnet-based systems. Specifically, the goals are to create a networking layer for Linux that can communicate using the DECnet protocol and to write user mode programs providing services compatible with those on DECnet-based machines, e.g. PHONE, email exchange, and remote filesystem sharing (DAP). This project is (7/98) still in the early beta stages. <P> A related project involves LinuX DECnet CTERM utilities including a DECnet socket layer and a set of high-level applications including a terminal emulator over DECnet using CTERM. Versions of the dncopy and dntype applications are also available.
[http://linux.dreamtime.org/decnet/]
[http://members.tripod.com/~emserrat/]
decision trees: One of the central techniques used in automated machine learning for analyzing, filtering and classifying huge amounts of data. Such methods are commonly used in, e.g. astronomy and DNA sequence analysis. Decision trees are particularly useful in that they perform classification via a sequence of simple tests whose semantics are intuitively clear to domain experts. See Brieman et al. (1984) and Safavin and Landgrebe (1991).
Related software includes:

CDT, an algorithm for the asymmetric traveling salesman problem;

C4.5, a program for inducing classification rules in the form of decision trees from a set of examples

OC1, a system for the induction of oblique decision trees;

ITI, a program for constructing decision trees using either incremental or direct metric tree induction;

IVODES, a decision tree for selecting suitable codes for solving initial value ODEs;

MLC++, a library of classes for supervised machine learning;

QUEST, a decision tree algorithm for classification and data mining with unbiased variable selection;

TiMBL, a machine learning program implementing a family of memory-based learning techniques; and

WEKA, a collection of machine learning methods linked together with a common file format and interface.
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.welcomehome.org/dejagnu.html]
delaundo: A package for creating triangular grids based on the frontal delaunay method. In this method the set of discretized curves that describe the boundary are first triangulated. New vertices are then created on frontal edges between well- and ill-shaped triangles such that a new triangle with the desired size and shape will result. New vertices are introduced in layers on the boundaries in a regular manner, with the regularity of the point distribution and element quality enhanced by an averaging process that tends to choose an equilibrium position between competing edges when a front is refined or coarsened. Delaundo can also produce stretched grids and has a multi-grid capability that can produce a series of coarsened grids with nested nodes. A source code distribution of this Fortran package is available. It is documented in a thesis available in PostScript format as well as in Müller (1994).
[http://www.cerfacs.fr/~muller/delaundo.html]
DeleGate: A multi-purpose application level gateway or proxy server. This mediates communications among various protocols (e.g. HTTP, FTP, etc.) by caching and converting data. It controls access from clieints and routing toward servers, and translates protocols between clients and servers, merging several servers into a single general purpose proxy server with aliasing and filtering.
The features of DeleGate include:

unbound proxying wherein a user can arbitrarily select target servers by specifying a destination in user level data specific to the protocol of the client;

bound proxying wherein the administrator can specify which destination server is used depending on the client;

caching of messages in their original format and sharing them among gateway servers with different protocols;

connection sharing wherein an established connection to a server can be reused and shared among multiple clients;

several built-in data conversion filters;

several protocol conversion filters;

relaying messages between clients and servers with and without SSL capabilities;

access control via destination protocol, destination server and source client;

detailed logging of all actions as well as protocol depending logging;

automatic invocation on demand or at boot time;

resolver control wherein the combination and sequence of multiple resolution mechanisms can be controlled independent of platform;

selecting routes to the server based on protocol, server and client;

merging multiple servers with multiple protocols into a single server with resource name filtering and aliasing; and

invocation of proxy on demand, e.g. for a current session.

A source code distribution of DeleGate is available. It can be compiled and used on most UNIX platforms with minor modifications. It is documented on the site and in an ASCII text file serving as a manual.
[http://wall.etl.go.jp/delegate/]
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: Note: As of 12/99 there is no sign of this at its orginal site or anywhere else. 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]
DEMODWT: Wavelet transform algorithms for finite-duration, discrete-time signals. This is TOMS algorithm 735 and is documented in Taswell and McGill (1994).
[http://www.acm.org/calgo/contents/]
Dents: A server for the DNS protocol as specified in RFC 1035. The features of Dents include:

compatibility with named such that it can be used as a drop-in replacement;

a modular driver system allowing for the dynamic binding of zones and corresponding code to answer DNS queries; and

an extensible control facility allowing an administrator to control the running server.

A source code distribution is available under the GPL.
[http://www.dents.org/]
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. Depot4 is similar to a compiler generator in that it accepts a grammar-based input language and produces a parser or translator from it. It differs in that it is designed for rapidly implementing translators rather than creating maximally efficient translators. The Depot4 metasystem consists of a meta-language compiler (i.e. a preprocessor), a library of modules for standard tasks and runtime support, and a user interface. Versions of Depot4 written in both Oberon and Java are available.
[http://www.math.tu-dresden.de/wir/depot4/]
detect: A hardware detection library which, while documented very sparsely, forms the underpinnings of the Lothar project.
[ftp://ftp.linuxmandrake.com/pub/lothar/SOURCES/]
DeTeX: A filter program that removes TeX and LaTeX control sequences from input files.
[http://www.cs.purdue.edu/homes/trinkle/detex/]
devfs: The Linux device file system is an alternative to the ``real'' character and block special devices on the root filesystem, i.e. the /dev directory. It allows kernel device drivers to register devices by name rather than by major and minor numbers. These devices will automatically appear in devfs, and with whatever default ownership and protection the driver specified. It consists of an underlying device namespace (i.e. a namespace like any mounted filesystem) and the filesystem code that provides a view of the device namespace.
The problems devfs was created to solve include:

the requirement that major and minor device numbers be allocated for each and every device, with the consequent requirement of a central coordinating authority to issue the numbers to preserve uniqueness (with devfs shifting the burden to a namespace);

two separate databases of major and minor numbers: one in the kernel and one in /dev;

well over 1200 nodes in typical /dev directories - most for devices that don't exist - with devfs offering a list of available rather than conceivable devices;

having the device nodes on the root filesystem means you can't operate with a read-only root filesystem;

non-UNIX filesystems can't be used for root filesystems;

PTY device would be increased by allowing a secure user-space daemon to run as root and create pty-pairs; and

device management would be more intelligent.

[http://www.atnf.csiro.au/~rgooch/linux/docs/devfs.html]
DeviceNet: A networking standard for industrial automation applications. It provides both peer-to-peer and master/slave communication and is designed to reduce hardwiring and provide access to device-level diagnostics. The DeviceNet communication link is based on the CAN (Controller Area Network) protocol.
[http://www.odva.org/]

ss5136dn

A device driver, a set of utility programs, and a function library for the SST model 5136 family of CAN Bus / DeviceNet interface cards. It rovides a programming library, driver module, and set of configuration and testing utilities for using the SST 5136-DN, and 5136-DNP, cards as a DeviceNet scanner under Linux. The package contains drivers for the ISA and PC104 versions of these cards as well as the PCMCIA version. These products are rebranded and sold under several vendor's names. Such rebranded products also work.
[http://sunsite.unc.edu/pub/Linux/hardware/drivers/]
DEVise: An environment for Data Exploration and Visualization is a data exploration system allowing the easy development, browsing and sharing of visual presentations of large tabular datasets from several sources. The features include:

a visual query interface;

efficient handling of datasets larger than RAM;

mapping from data to graphics at record level;

querying of data records used to represent graphics;

a flexible layout mechanism within windows;

linked axes;

use of cursor to compare relationships between different data views;

record-based input data;

direct input of ASCII files; and

handling of several data types including integer, float, data and string.

[http://www.cs.wisc.edu/~devise/devise.html]
DFM: Desktop File Manager is a file manager for UNIX systems designed to emulate the OS/2 WPS program. File are shown as icons and every folder has its own window, with the desktop background being a special folder in the home directory. The features of DFM include:

icons can have any size or position;

XVPICS can be shown as icons;

constant position icons that cannot be moved;

easy addition of new programs to the desktop;

drag and drop support; and

detail and structure views.

This was built using the GTK library.
[http://dfm.linuxbox.com/]
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/]
DGL: The Data Generation Language is a language that can be used to generate various kinds of test data. It was originally designed to generate functional level test for VLSI designs but has been used to generate tests for both software and hardware with tests generated either systematically or randomly. It is particularly adapted to situations requiring the random selection and printing of data. DGL is based on the concept of context-free grammars with significant additions to expand the generating power of the language. A C language source code distribution is available and is a collection of examples and an extensive test suite. Documentation includes a user's manual and a couple of technical reports.
[http://www.csee.usf.edu/~maurer/dgl.html]
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/products/DHCP/]
[http://www.ietf.org/html.charters/dhc-charter.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://www.phystech.com/download/dhcpcd.html]
[http://sunsite.unc.edu/pub/Linux/system/Network/daemons/]

JDHCP

A project to add DHCP support to Java.
[http://www.eg.bucknell.edu/~jgoldsch/dhcp/]
DHTML: Dynamic HTML is a sort of buzzword for Web pages that combine HTML, CSS and JavaScript to enhance their interactive functionality. It can be used to create animations, games, applications, novel site navigation methods, and page layouts that aren't possible with just HTML.
Related packages include:

DynAPI, an Open Source project for developing a code library for programming DHTML

[http://www.dhtmlzone.com/index.html]
[http://www.dansteinman.com/dynduo/links.html]
Dia: A program for drawing various kinds of diagrams that is sort of based on the Windoze program Visio. The current (8/98) beta version has support for UML static structure diagrams (i.e. class diagrams) and network diagrams. It can also load and save diagrams to either a custom file format or export them in PostScript format. A source code distribution is available.
[http://www.lysator.liu.se/~alla/dia/dia.html]
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]
DIALIGN: An alignment program for nucleic acid and protein sequences that relies on comparison of whole segments of the sequences rather than comparison of single residues. Pairwise as well as multiple alignments are constructed from gapfree pairs of equal length segments, with these segment pairs called diagonals. DIALIGN doesn't use a gap penalty and therefore is especially suited for the detection of local similarities in other completely unrelated sequences. Binary distributions are available for several platforms including Linux Intel.
[http://www.gsf.de/biodv/dialign.html]
DialoX: A distributed human/computer interaction (HCI) server tailored for use with symbolic programming languages such as April. DialoX contains a combination of window primitives, graphics capabilities, and a high-level approach to constructing GUIs for agent applications. In this approach the task of building the code need for the GUI is delegated to the server, i.e. applications interact with the server via a special purpose protocol that allows the appplication to request that particular windows be constructed as well as notify the application via a message when the user invokes an action in the window. The descriptions of user interface elements are written as external resources to the application using an XML-based notation. The application only has to manage the top-level invocation of the windows and the responses from the user. This is part of the larger Network Agents project.
[http://www.nar.fujitsulabs.com/dialox/]
Diary: A program for storing and keeping track of notes. Diary allows notebooks to be created and entries added, deleted and modified. The notes can be browsed and searched. The features include:

universal access via web browsers;

collaboration by specifying permission for one or more other users to use a notebook; and

a choice of making any notebook as private or public as you want.

This is a PHP package that also requires MySQL.
[http://keilor.cs.umass.edu/diary/]
DICT: The DICTionary Server Protocol is a TCP transaction based query/response protocol allowing a client to access dictionary definitions from a set of natural language dictionary databases. It is fully described in RFC 2229.
[http://www.dict.org/]

dictd

A client/server software package implementing the DICT protocol. The programs comprising the package include:

dict, a client that can access DICT servers from the command line;

dictd, a server supporting the DICT protocol; and

dictzip, a program that creates compressed files in a modified gzip format that compresses the file in pieces and stores and index in the header.

A source code distribution of dictd is available which can be compiled on most UNIX flavors including Linux.
[http://www.dict.org/announce.html]

Word Inspector

A GTK-based graphical front-end to the client program in the dictd package. A source code distribution is available.
[http://www.tir.com/~sgifford/wordinspect/]
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]
DIESEL: The Dumb Interpretively Executed String Expression Language is the kernel of a macro language that can be customized by adding C code and embedding it in a program. It is short, written in portable C, and useful for programs that need a rudimentary macro expansion facility without the complexity of a full language like Forth. This was developed for menu macro processing in AutoCAD and has been released into the public domain. See also the same author's ATLAST language.
[http://www.fourmilab.ch/diesel/]
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 (1983a).
[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 (1983a).
[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 (1983a).
[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;

Differentiation Matrix Suite, Matlab functions for solving DEs using spectral collocation;

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.
Differentiation Matrix Suite: A set of Matlab functions for solving differential equations using the spectral collocation or pseudospectral method. The routines include those for:

computing differentiation matrices of arbitrary order corresponding to Chebyshev, Hermite, Laguerre, Fourier and sinc interpolants;

FFT-based routines for Fourier, Chebyshev and since differentiation; and

auxiliary routines for incorporating boundary conditions, performing interpolation using barycentric formulas, and computing roots of orthogonal polynomials.

This is documented in a report available in PostScript format.
[http://ucs.orst.edu/~weidemaj/differ.html]
DiffMan: An object-oriented Matlab toolbox for solving differential equations on manifolds based on the concept of coordinate free numerics.
[http://www.ii.uib.no/diffman/previous/]
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.org/software/diffutils/diffutils.html]
Digital-Phalanx: A UNIX security daemon that allows only specified users from specified domains log on to a server. A source code distribution of this Perl script is available.
[http://www.marketrends.net/phalanx/]
Dime: The DXF Import, Manipulation and Export package is a C++ class library for reading, constructing, manipulating and writing DXF file data. The DXF file format was first created for use with AutoCAD but is now more widely used. The functionality of Dime includes:

loading DXF files into a Dime object hierarchy containing the data;

building Dime object hierarchies from scratch;

extracting geometry data from Dime object hierarchies;

manipulating Dime object hierarchies;

traversing the Dime object hierarchies while performing various tasks; and

saving Dime object hierarchies as files conforming to DXF.

This is available under the GPL, version 2.
[http://www.sim.no/dime.html]
DING: A newsreader for Emacs whose name has been changed to Gnus.
DINO: A high-level, dynamically-type scripting language intended for the same application domain as Perl and Python. DINO resembles C, is object-oriented, and has garbage collection. It also has exception handling and is extensible via dynamic loading of libraries written in other languages. The high-level structures are heterogeneous and extensible arrays, extensive associative tables, and objects.
[http://www.freespeech.org/vmakarov/dinoload.html]
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(N) 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/]
DIRECT (optimization): A Fortran implementation of the DIviding RECTangles algorithm for finding the minimum of a Lipschitz continuous function. DIRECT is designed to solve problems subject to box constraints.
[http://www4.ncsu.edu/~jmgablon/]
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]
Discus: A WWW discussion board software package whose features include:

network management tools;

a simple user interface;

keeping track of what's already been read via marking of unvisisted links;

fast loading wherein messages in a discussion are all on the same page;

formatting including images and tables without HTML;

public and private topics;

keyword and new message searching;

organizational capabilities including infinite subtopic depth;

comprehensive online documentation;

an email notification option;

user profiles; and

option of frames or no frames.

A source code distribution is available which requires a WWW server and Perl 4 or 5. This will work on both UNIX and non-UNIX platforms.
[http://www.chem.hope.edu/discus/home/]
Diskdrake: An Open Source hard disk partitioning program whose features include:

creating and deleting partitions;

changing partition type;

formatting partitions;

assigning mount points;

mounting partitions;

resizing FAT partitions;

resizing other types of partitions;

clearing partition tables;

auto allocation; and

writing fstab.

This uses and requires both Perl and Gtk-Perl.
[http://www.linux-mandrake.com/diskdrake/]
DiskSim: An efficient, accurate, and highly configurable disk system simulator developed to support research into aspects of storage subsystem architecture. DiskSim includes modules for most secondary storage components including device drivers, buses, controllers, adapters and disk drives. It also includes support for a number of externally-provided trace formats and internally-generated synthetic workloads as well as hooks for inclusion in a larger scale system-level simulator. A source code distribution is available. It is written in C and requires only basic POSIX interfaces and no special system software. A user's manual is available in PostScript format.
[http://www.ece.cmu.edu/~ganger/disksim/]
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.linmpi.mpg.de/dislin]
[ftp://ftp.gwdg.de/pub/grafik/dislin]
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/Multiple_Scatt/]
[http://climate.gsfc.nasa.gov/~wiscombe/]
Display PostScript (DPS): A graphics display system that provides the same imaging model for both printers and active computer displays. DPS provides a device-independent imaging model for displaying information on a screen that is fully compatible with the model used in PostScript printers.
[http://dps.sourceforge.net/]

DPSLib

The Display PostScript client Library developed by Adobe for writing applications that use the DPS extension to X11. The main components of the package include:

dps, the interface library;

dpstk, a toolkit of useful routines for DPS programmers; and

psres, utilities to locate fonts and other PostScript resources.

[ftp://dps.sourceforge.net/pub/dps/]

DPS/X

A DPS extension for XFree86. In this extension, DPS clients interact with the server by requesting that it execute wraps (i.e. pieces of PostScript code) in a manner that simulates a procedural API. DPS/X is a platform-independent loadable server module for XFree86 3.9.18 or later. It is currently (3/00) in pre-alpha stage.
[http://dps.sourceforge.net/]
Display Signal: A GUI for viewing signal waveforms that includes tools for viewing energy, signal and spectrogram plots as well as for selecting signals and audio playback. The features of the main tool include zooming in and out, setting time marks, playing audio on mono channels, and setting user-defined configurations. The energy plotting window allows setting canvas size, frame and window length, RMS scale factor, preemphasis coefficient and window function. The signal plot window allows changing the amplitude, volume and setting the audio device and server. The spectrogram window features include changing the brightness and contrast ans setting the preemphasis coefficient and window function. Currently (5/99) only 16 bit single channel linear (i.e. RAW) data is supported.
A source code distribution is available. This was build using C++ and Tcl/Tk and has been successfully compiled using GCC.
[http://www.isip.msstate.edu/projects/speech/software/display_signal/]
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/]
distributions: A Linux distributions includes a kernel and various ancillary software for creating a usable system. In addition to the major free and commercial distributions that include everything and the kitchen sink, there are several smaller distributions created for specific purposes. These include:

DLX

A Linux system on a single floppy disk. DLX boots with a 1.3.89 kernel and starts a ramdisk image. The boot disk includes an ext2 filesystem of about 130 kb. A ZIP drive can be mounted with a special /usr/local/ directory which allows larger programs to be used. This was designed for network troubleshooting or FTPing from a PC unlucky enough to not have Linux installed.
[http://www.wu-wien.ac.at/usr/h93/h9301726/dlx.html]

DragonLinux

An Internet-ready Linux operating system that includes tools for networking with LANs, SLIP and PPP. The full installation takes up just 25 Mb. DragonLinux is UMSDOS-based, i.e. it co-exists with WinDOS on the same partition.
[http://www.c-cubedinc.com/dragon/]

floppyfw

A single floppy containing sufficient Linux mojo to turn a PC into a static router with firewall capabilities. It does not have all the capabilities of a firewall and is better thought of as a screening router. The capabilities include:

accesslists and IP masquerading controlled by ipchains;

port forwarding using ipmasqadm; and

requiring only a 386sx or better, two network interface cards, a floppy drive, and 8 Mb of RAM.

[http://www.zelow.no/floppyfw/]

Green Frog Linux

A compact Linux distribution designed for those who want to start with the minimum and design their own system from there. This is a bare minimum system which can be booted, compile most thing, and perform most basic network operations. It requires around 140 Mb fully installed.
[http://www.linuxstart.com/~austin/GreenFrog/]

hal91

A minimal Linux distribution that fits on a single floppy disk and is intended for use as a rescue disk or as a portable Linux system. This contains only the most vital files needed to get a system up and running.
[http://home.sol.no/~okolaas/hal91.html]

LEM

Linux EMbedded is a small Linux distribution that provides embedded software developers with a multi-user, networked OS with an X11 server.
[http://www.linuxembedded.com]

LOAF

Linux On A Floppy is a small Linux distribution that fits on a single floppy. It is meant to be used as a client for various network protocols and programs including Lynx, FTP, Telnet and ssh. LOAF will boot a machine from a floppy and install itself in RAM (since it has no support at all for hard drives) until the computer is shut down. It currently (12/98) recognizes about a dozen popular network cards, with a separate floppy disk image available for each of the supported cards.
[http://www.ecks.org/loaf/]

LRP

The Linux Router Project is a project to create a minimal Linux distribution that makes building and maintaining routers, terminal servers, and embedded networking systems an easy task. The features of the LRP distribution include:

support for several interfaces including Ethernet, WAN, Wireless, ISDN, serial and parallel;

support for several protocols including base RIP, BGP IP - IP OSPF and others via packages;

IP control via policy firewall, IP masquerading, port redirection and translation, port load balancing, transparent proxy, numberless interface spanning, interface load balancing, and interface aliasing;

advanced routing including IPX, Token Ring, tunneling, crypto VPN, traffic limiting and shaping, and policy based routing; and

traffic monitoring of all SNMP interfaces as well as TCPDump.

The LRP distribution fits on a single floppy disk.
[http://www.linuxrouter.org/]

muLinux

A small Linux distribution whose aim is to demonstrate the power and scalability of the system. A compiled kernel has been modularized as much as possible and various binaries are included. The smallest binary versions of various programs have been chosen, and if the smallest isn't considered small enough then some programs have been rewritten and recompiled for minimum binary size. This could be used for demonstration or maintenance purposes or just to show how much of a usable system can be contained on one disk. The details as to just which utilities and programs the disk contains are available at the home site.
[http://sunsite.auc.dk/mulinux/]

Pocket Linux

A minimal one floppy system designed to quickly convert a PC into a secure Linux-based workstation using ssh to connect to a remote host. This supports bootp for determining the host IP and other networking parameters. This can be used with a machine that has either a network card or a modem, with both automatically detected.
[http://pocket-linux.coven.vmh.net/index.html.en]

Small Linux

A small, single-floppy Linux distribution with ELF format libc5 that will boot in less than 2 Mb of RAM. This uses kernel version 1.2.11 and includes enough utilities to do most basic things.
[http://smalllinux.netpedia.net/]

tomsrtbt

A Linux distributino on a single floppy disk for system rescue, recovery, panic and other emergencies. It consists of as many useful utilities as could be made to fit on a single floppy disk and still be self contained and capable of building under itself. It includes various modules, man pages, links, scripts, binaries and, of course, a kernel. A complete list of the contents of the disk is available at the home site.
[http://www.toms.net/rb/]

Trinux

A security-related Linux distribution that runs from only two ramdisks - one for the root partition and one for the usr partition. It can run on 486 machines with at least 16 MB of RAM and supports several network cards as well as the usual network tasks such as IP aliasing, firewalls, forwarding, etc. The distinguishing feature of Trinux is that it includes the latest versions of several popular security tools. This distribution is available as a couple of image files.
[http://www.trinux.org/]

Xdenu

A small Linux distribution whose main goal is to provide a minimal X terminal connection in a networking environment. The two versions of Xdenu are:

FloppyX, a distribution of Linux and XFree on two floppies that is booted and run from the floppies;

HdX, a Linux system on top of a DOS filesystem consisting of one self-extracting DOS archive.

[http://xdenu.tcm.hut.fi/]

zdisk

A single floppy disk distribution containing a kernel and a rescue system. This copies a chosen kernel (smaller then 720 Kb) to a floppy and includes the rescue system on the same floppy. This also contains the fsresize program which can be used to resize a FAT16 or FAT32 DOS/WIN partition.
[ftp://metalab.unc.edu/pub/Linux/system/recovery/]
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/]
DjVu: A library implementing a compression technology for reducing high quality scanned images of printed matter consisting of images, text or both to manageable size. The three kinds of DjVu image files are:

photo DjVu images for encoding photographic images in colors or shades of gray;

bilevel DjVu images for compressing black and white images representing text and simple drawings; and

compound DjVu images with a background layer for encoding pictures and paper texture and a foreground layer for encoding text and drawings.

The library also includes software for working with IW44 image files, a wavelet-based format for color and grayscale image files.
The capabilities of the DjVu Reference Library include:

decoding DjVu and IW44 images;

rendering DjVu or IW44 image fragments at any resolution;

encoding IW44 images;

creating DjVu photo images, i.e. basically embedded IW44 images;

creating lossless, bilevel DjVu images using lossless encoding;

creating compound DjuVu images for electronically produced images; and

creating DjVu images from scanned images.

Executables for compressing scanned images in the DjVU format are additionally available for several platforms. A 200+ page manual for the library is available in PostScript format.
[http://www.djvu.att.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.org/software/dld/dld.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.domtools.com/dns/dlint.shtml]
dlv: A deductive database system based on disjunctive logic programming which offers front-endss to several advanced KR formalisms including brave and cautious reasoning, abductive diagnosis, Reiter's diagnosis, and a subset of SQL3. The native dlv language is Disjunctive Datalog extended with constraints, true negation and queries. The basic elements of this language are constants which refer to entities similar to objects stored in relational databases. Command-line prototype binary versions of dlv are available for a variety of platforms including Linux Intel.
[http://www.dbai.tuwien.ac.at/proj/dlv/]
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/]
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.dmalloc.com/]
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.
[http://youpou.lip6.fr/queinnec/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); and

use of Remote Method Call (RMC) for distributed objects without additional programs.

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]
DMTTEQ Toolbox: A Matlab toolbox for designing and testing various time domain equalizer design methods including:

minimum mean squared error with unit energy or tap constraint;

maximum shortening signal to noise ratio method;

maximum geometric SNR method;

divide and conquer by cancellation or minimization;

maximum channel capacity method;

minimum intersymbol interference method; and

regular and modified matrix pencil design method.

[http://anchovy.ece.utexas.edu/~arslan/dmtteq/dmtteq.html]
DMV: A Fortran program for calculating the multivariate normal integral. This is TOMS algorithm 725 and is documented in Drezer (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]

Next: Dn-Dz Up: Linux Software Encyclopedia Previous: Cn-Cz Contents

Manbreaker Crag 2001-03-08