Next: Ea-Em Up: Linux Software Encyclopedia Previous: Da-Dm Contents

Dn-Dz

Last checked or modified: Dec. 12, 1999

DNA analysis: Related packages include:

CINEMA, for the visualization and manipulation of protein and DNA sequences;

CloneIt, for finding sub-cloning strategies, in-frame deletions and frameshifts using restriction enzymes and DNA polymerases;

DCSE, a multiple alignment editor for protein, DNA or RNA;

Delila, for the analysis of protein and nucleic acid sequences;

Dynamite, a language for the automatic generation of sequence comparison methods;

FASTA, a toolset for biological sequence analysis;

MEME, a tool for discovering and using protein and DNA sequence motifs;

Meta-MEME, a tool for building and using motif-based hidden Markov models of DNA proteins;

MOLPHY, a package of programs for molecular phylogenetics;

Network Entrez, for browing bibliographic, nucleotide sequence, genome, protein sequence and 3-D structure databases;

PAML, for the phylogenetic analyses of DNA or protein sequences using the method of maximum likelihood;

PHYLIP, programs for performing phylogenies on DNA, protein sequences, restriction sites, etc.;

Quant2, for extracting signal patterns in DNA sequences using a discriminant analysis technique;

RSVP, a suite of visually-oriented sequence analysis routines implemented in PostScript;

Sequin, aids in the submission of sequences to various databases;

SITES, for the analysis of comparative DNA sequence data; and

statalign, for estimating parameters relevant to the evolutionary relationship between pairs of DNA or protein sequences.
DNA-GUI: An interactive GUI for the rapid and efficient analysis of images of the types used in genome mapping, e.g. autoradiograms and electrophoretic gels. The images are digitzed with a CCD camera system and analyzed with a menu-driven user interface. The features include:

automatic lane and band detection;

simultaneous display of multiple images;

automatic fragment sizing;

zooming, shrinking and panning images;

displaying and manipulating 1-D profiles;

interactive color table adjustments;

allele propagation for 2-allele inheritance;

a unique spatial-normalization algorithm; and

archiving of images and their associated data.

A Linux binary is available at the second URL below, while the first is the home site of the package.
[http://www.ibc.wustl.edu/bcl/dnagui/]
[ftp://ftp.rhrz.uni-bonn.de/pub/institute/meb/molbio/linux/]
DND: The Drag aNd Drop protocol is a C interface to Xt-based programs available together with OffiX, a collection of useful utilities.
[http://leb.net/~offix/dnd.html]
DNS: The Domain Name System is a distributed database that holds the alphanumeric names and IP addresses of every registered system on the Internet. The databases are maintained by systems running name servers, usually the BIND package. The DNS allows the translation of names to IP addresses in a process called name resolution. The databases are distributed with, for example, a local server holding the mappings of names to addresses for a group of local hosts. In addition to these domain-specific servers there are mid-level servers that maintain data from several domains. At the top are root name servers containing the data for all of the top level domains, e.g. com, org, net, us, uk, gd, etc. The root name servers enable every host on the Internet to hierarchically access the complete DNS database. See Albitz and Liu (1996), Albitz and Liu (1998) and Branley (2000).
Available DNS server software includes:

BIND, the Berkeley Internet Name Domain;

Dents, a DNS implementation;

LB, a load balancing name server written in Perl.

Available DNS management tools include:

dlint, a DNS verification utility;

DNScache, a collection of DNS tools developed with an emphasis on security;

DNStool, an auto-configuration system;

dnsutl, a package of utilities for DNS configuration;

dnswalk, a DNS database debugger;

doc, a tool for diagnosing unhealthy DNS domains;

domtools, a set of high-level name server query tools;

GASH, a large-scale systems administration system which, among other things, automates NIS and DNS administration;

hiermap, a set of utilities that take raw hierarchical data and create a PostScript map showing the relationships, e.g. a domain name hierarchy;

host, a nameserver query utility intended to update nslookup and dig;

WEBDNS, a Web utility for editing DNS master files;
DNScache: A collection of DNS tools developed with an emphasis on security, i.e. the package is structured to minimize the complexity of security-critical code. The components of the package include:

dnscache-conf, sets up a DNS cache service, i.e. dnscache;

dnscache, runs a local DNS cache, i.e. accepts recursive DNS queries from local clients and collects responses from remote DNS servers;

tinydns-conf, sets up a DNS publication service, i.e. tinydns;

tinydns, a DNS server that accepts iterative DNS queries from Internet hosts and responds with locally configured information;

tinydns-data, creates binary data files from local DNS information for fast access by tinydns;

pickdns-conf, sets up a load-balancing DNS publication service, i.e. pickdns;

pickdns, a load-balancing DNS server that accepts queries from Internet hosts and responds with a dynamic selection of locally configured IP addresses with 5-second TTLs;

pickdns-data, creates binary data files from local IP addresses for fast access by pickdns;

walldns-conf, sets up a DNS wall service;

walldns, a reverse DNS wall, i.e. it accepts iterative DNS queries for in-addr.arpa domains from Internet hosts and supplies generic responses that avoid revealing local host information;

rbldns-conf, sets up an IP address listing DNS service;

rbldns, an IP address listing DNS server that accepts iterative DNS queries from Internet hosts asking about various IP addresses, providing responses showing whether the addresses are on a locally configured list such as RBL or DUL;

rbldns-data, creates binary files from IP address lists for fast access by rbldns;

axfrdns-conf, sets up a DNS zone transfer service;

axfrdns, a DNS zone transfer server that reads zone transfer requests in DNS-over-TCP format and responds with locally configured information; and

axfr-get, a DNS zone transfer client that sends zone transfer requests in DNS-over-TCP format to descriptor 7 and reads the results from descriptor 6, saving the results to a file.

Other utility tools in the package include:

dnsip, prints IP addresses;

dnsipq, prints fully qualified domain name and IP addresses;

dnsname, does a reverse lookup for an IP address;

dnsmx, prints MX records;

dnstxt, prints a TXT record;

dnsq, a debugging tool that sends a non-recursive DNS query to a server and prints the results;

dnstrace, searches for all DNS servers that can affect the resolution of a given record.

[http://cr.yp.to/dnscache.html]
dnsdomainname: See NetTools.
DNStool: A DNS auto-configuration system designed to ease the management of DNS. DNStool accomplishes this by automatically generating DNS files from a small number of configuration files, thus eliminating the almost inevitable mistakes caused by hand-editing the complex and tedious format of the DNS files. It reduces the task of maintenance to maintaining a database describing its hosts for each domain, maintaining a description of the common features across domains, and running the configuration programs to generate and install the files.
A source code distribution of DNStool is available. It is written in Perl and requires version 5 of that language. It is documented in a user's manual included in the distribution.
[ftp://ftp.uniq.com.au/pub/tools/dnstool/guide.html]
dnsutil: A package of utilities to make DNS configuration easier. The utilities include:

dns-rev, which takes a forward DNS mapping and generates the reverse mapping;

dns-hosts, which takes the forward DNS mapping and generates the /etc/hosts file;

dns-ng, which takes the forward DNS mapping and generates the /etc/netgroup file;

dns-bootp, which generates bootp tables from DNS tables;

dns-bootprms, which generates /etc/bootparams entries from DNS tables;

dns-ethers, which generates /etc/ethers entries from DNS tables; and

dns-filter, which filters DNS database files.

The dnsutl package includes the source code which is written in ANSI C. It has been successfully compiled on several UNIX platforms using the included autoconfig file. The utilities are documented in man pages.
[ftp://ftp.agso.gov.au/pub/Aegis/]
dnswalk: A DNS database debugger which works by initiating a zone transfer of a current zone, inspecting individual records for inconsistencies with other data, and generating warnings and errors. It doesn't parse DNS data files but works via existing DNS query methods on a live system. A source code distribution of dnswalk is available. It is written in Perl and requires 5.003 or newer.
[http://www.cis.ohio-state.edu/~barr/dnswalk/]
doc: A tool for diagnosing unhealthy DNS domains. Doc automatically verifies (to an extent) that a domain is configured and functioning correctly. It doesn't validate the data inside a domain but only the structure of the domain. A source code distribution of doc is available.
[ftp://ftp.is.co.za/networking/ip/dns/doc/]
DOC++: A source code documentation system for C/C++ and Java that can produce output in several formats including LaTeX and HTML formats. The documentation is extracted directly from C++ header or Java class files. The features of DOC++ include:

hierarchically structured documentation;

automatic generation of class graphs as Java applets for HTML;

cross referencing; and

high-end formatting support including equation typesetting.

Source and binary distributions are available.
[http://www.linuxsupportline.com/~doc++/]
DocuGen: A program that can be used to facilitate the creation of complex documents in several formats from the same source code file. DocuGen can output documents in HTML, ASCII test, ANSI text, and Platform Independent Text formats. It has extensive support for HTML document creation including document templates, include files, automatic image sizing, detailed data and time functions, and much more. Binary distributions are available for Linux Intel and Windows NT/95 platforms. A user's manual is available online in HTML format.
[http://www.brim.net/docugen/]
Doc Welder: A tool for building documents, especially using HTML. It uses four types of files to assemble a Web site (or a document or a program or anything else that is text-based). Template files look mostly like the final target except that they use variables (called Symbols) for commonly used features. Data files contain the data associated with specific Symbols. Site Control files specify which data files are used with which template files to build a specific target file. Finally, Libraries supply great flexibility in defining and producing specific document types. Doc Welder is written in Perl.
[http://www.cgibuilder.com/welder/]
DODS: The Distributed Oceanographic Data System is a package for providing and accessing data over the net in a consistent way. DODS is designed to link data handling applications with disparate datasets in remote locations. It uses a client-server model wherein a client sends a request to a server, which in turn answers with the requested data. The DODS architecture consists of three main components:

a server with a set of CGI scripts specific to the format of the data being served;

clients that use DODS functions to request data from servers, and also to interpret the results received from the server in a particular data format; and

functions including a core library and a variety of ancillary libraries that each support a different data access API.

The DODS APIs are designed to accurately mimic the behavior of several commonly used scientific data APIs. The currently supported APIs include those for NetCDF, JGOFS, HDF, DSP, GRIB, BUFR, FreeForm (arbitrarily formatted data including relational and gridded data), and native DODS format. The API set is extensible and can be used to write DODS-compliant versions of new APIs. The DODS Toolkit software consists of a collection of C++ classes used to build servers and clients. It consists of:

a complete implementation of the DODS data access protocol (DAP), i.e. a set of virtual classes for different types of data;

a set of classes designed to contain information about a dataset's data (i.e. metadata), including the Data Descriptor Structure (DDS) and the Data Attribute Structure (DAS);

a set of connect classes used by clients to mimic a durable connection to a DODS server;

a class containing several utility functions useful for writing servers; and

a set of classes providing various needed CGI functionality.

[http://www.unidata.ucar.edu/packages/dods/]
DOGMA: The Distributed Object Group Metacomputing Architecture allows applications to be written for and run on large groups of networked computers. DOGMA is built using Java RMI and JDK 1.1 and applications are essentially parallel Java applications.
The features of DOGMA include:

dynamic configuration of system topology so clusters can be grown or shrunk on the fly;

other than a small amount of local system class files all remaining code is served to nodes via HTTP;

methods can be invoked on entire object groups;

automatic data partitioning by the system at the user's request;

partitioning according to node speed and load;

data returned from group method invokations is reassembled by the system;

members of object groups can communicate with each other in point to point or broadcast modes;

users can interactive with the system via a web browser; and

an MPI implementation called MPIJ which supports many of the basic MPI functions.

A source code distribution of DOGMA is available. It requires JDK 1.1 or greater for installation and use. It has been tested on several systems including Linux Intel. Documentation is included with the distribution.
[http://zodiac.cs.byu.edu/DOGMA/]
DOM: The Document Object Model is a platform- and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure and style of documents. It provides a standard set of objects for representing HTML and XML documents, a standard model of how these objects can be combined, and a standard interface for accessing and manipulating them. The goal of the DOM specification is to define a programmatic interface for XML and HTML. This will serve to increase the interoperability of the Web as vendors support the DOM as an interface to their proprietary data structures and APIs and as content authors write to the standard DOM interfaces rather than to product-specific APIs - well, that's the plan, anyway.
[http://www.w3.org/TR/REC-DOM-Level-1/]

4DOM

An implementation of the DOM specification for Python. 4DOM implements the DOM Core level 1 and HTML level 1 and was designed from the start to work in a CORBA environment. It currently (11/98) supports Fnorb in this regard. A source code distribution is available.
[http://fourthought.com/4Suite/4DOM/]

TclDOM

A Tcl language binding for the DOM.
[http://www.zveno.com/zm.cgi/in-tclxml/in-tcldom/]
DOM: The Discrete Ordinates Method is a polarized multi-dimensional discrete-ordinates radiative transfer model for remote sensing applications. It can solve the monochromatic vector radiative transfer equation taking into account polarization using the four Stokes parameters and the 4x4 scattering phase matrix. The equation can be solved for systems containing thermal and/or collimated radiant sources as well as background sources of radiation in anisotropically scattering 1-, 2-, or 3-D Cartesian geometries. Boundary conditions can be used to account for a variety of surfaces via the use of polarized emission vectors and bidirectional reflectance matrices.
A source code distribution of DOM is available. It is written in Fortran and has the capability of using the PVM message passing library to distribute the computational load over several distributed machines. A vectorized version called VDOM is also available. The code and its use are documented in the author's dissertation which is separately available in PostScript format.
[ftp://iihr.uiowa.edu/pub/hml/haferman/]
domain decomposition: See the Domain Decomposition Methods Web site.
domainname: See NetTools.
domain-specific languages: A domain-specific language (DSL) is a programming language dedicated to a particular domain or problem. A DSL provides appropriate built-in abstractions and notations and is generally small, more declarative than imperative, and less expressive than a general purpose language, e.g. C. These have also been called micro-languages, application languages, specification languages and very high level languages (VHLL). Well-known examples of DSLs include make and UNIX shells. The latter are DSLs whose domain abstractions and notations include streams and operations on streams.
Some other examples of DSLs and DSL-related projects include:

ADL, a formal grammar for describing the behavior of programming interfaces;

Csound, languages for describing instrument audio generation and compositions created with those instruments;

Depot4, a translator generator designed for the rapid implementation of translators;

GAL, for describing video device drivers;

GemMex, a system for specifying the formal semantic of domain-specific and general purpose programming languages;

Merle, a scripting language for constructing information systems;

PLAN, a functional language for using a form of RPCs to realize active networking;

Rebol, a messaging language providing connectivity to most common Internet protocols;

TXL, a programming language and rapid prototyping system designed for supporting transformational programming.

[http://www.irisa.fr/compose/dsl/dsl_overview.html]
Dome: The Distributed Object Migration Environment provides a C++ library of distributed objects for parallel programming. These objects perform dynamic load balancing and support fault tolerance. This package can be used to write parallel programs that are automatically distributed over a heterogeneous network, dynamically balanced as the program runs, and able to survive compute node and network failures. The focus of the Dome system is to support parallel programming over networks of workstations. It uses a single program multiple data (SPMD) model to perform the parallelization of programs using the Dome library and PVM to provide its underlying process control and message passing. The source code is available in a package that also includes makefiles, related build scripts, documentation, and example programs.
[http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ nectar-adamb/web/DomeRelease.html]
DOME: The DOmain Modeling Environment is a meta-CASE system for building object-oriented software models as well as original types of models. It is an extensible system for graphically developing, analyzing and transforming models of systems and software. DOME comes with a pre-built set of notations including Coad-Yourdon OOA, Colbert OOSD, IDEF0, Petri-Nets and a simplified form of UML, although its major strength is its ability to build specialized new notations. Notations are defined by filling in properties on its object model using the DOME Tool Specific Language (DTSL). The definition can include object class, property and relationship definitions, connector types, dynamic object appearances, tool buttons, menus, annotations, and semantic relationships. Graphical languages can also include textual, numeric and symbolic annotations.
The DOME tools include:

ProtoDOME, for building new notations and running them in an interpreted mode;

Projector, a code generation tool using a visual dataflow language;

Alter, a textual version of Projector that provides the functionality to write complex model transformations.

Binary distributions of DOME are available. It is written in the VisualWorks Smalltalk environment, for which free noncommercial versions are available for Linux. Documentation includes several user's manuals for the various package components.
[http://www.htc.honeywell.com/dome/]
DOME (geodesic): A program for generating the coordinates of a geodesic dome or sphere. The features of DOME include:

generation of data files in several formats including DXF, POV, WRL, DAT and PRN;

support for tetrahedron, octahedron and icosahedron polyhedron types;

generation of symmetry triangles and full spheres for class I and II structures;

``buckyball'' structuring;

elliptical geodesics; and

functions for calculating point, edge and face coordinates.

The distribution includes a DOS executable, source code and a makefile for UNIX platforms.
[http://www.cris.com/~rjbono/html/domes.html]
DOME (CORBA): The Distributed Object Management Enviroment is a high performance C++ toolkit for the implementation of distributed systems using the OMG CORBA architecture for Object Request Brokers (ORBs). DOME allows services, data, and applications to be easily and effectively distributed across heterogeneous systems.
The features of DOME include:

multi-threading and asynchronous operation;

virtual callbacks from the server;

synchronous and asynchronous calls to the server;

location broking for location transparency;

connection groups; and

networking monitoring and debugging.

It works with GUI toolkits such as C++Views, Motif, and OpenLook and can be integrated with C and C++ applications of all types. It supports multiple concurrent protocols such as TCP/IP, NetBIOS, XTI, ISDN and ATM.
The binary Linux version of DOME is freely available for personal use. The package is documented in several documents available in PostScript format, including an introductory tutorial and a library reference manual.
[http://www.realobj.demon.co.uk/]
domtools: A set of high-level name server query tools that allow you to traverse DNS domain hierarchies, list all hosts or subdomains within a given domain, convert host name to IP address and vice-versa, convert a normal IP address to the ``in-addr.arpa.'' format and vice-versa, and much more. The tools are grouped by level, where level 1 contains basic function tools for computing netmasks, performing address format conversions, and other tasks that don't require nameserver usage. The level 2 tools do simple domain record lookups using dig. The level 3 tools perform much more complex tasks, combine several tools from the previous levels, and can take some time to run. The level 1 tools are addr2mask, addr2net, f2iaddr, i2faddr, type, isequal, issubdom, netwithzeros, netkillzeros, ipsort, domsort, basedomain, rndarg, gensubnetlist, localad, and localdom. The level 2 tools are ns, zone, root, nsroot, address, ptr, hinfo, uinfo, soa, txt, any, wks, mx, cname, axfr, nsap, gw, netname, subnetmask, network, netmask, subdom, subzone, and hosts.
The level 3 tools are:

soalist, which tells DNS admins what nameservers are supposed to be authoritative for their domain according to its parent domain (as well as the SOA record of each of those servers);

cachebuild, which queries root domain name servers for a complete list of root domain name servers and then generates a new BIND root.cache;

makestatic, which runs the hosttbl, networktbl and netmasktbl scripts, usually from cron at regular intervals;

hosttbl, which generates a table of host information in the format of the static host file used by some UNIX machines in place of name service;

networktbl, which generates a table of network information in the format of the static networks file used by some UNIX machines;

netmasktbl, which generates a table of network information in the format of the static subnet masks file used by some UNIX machines;

check1101, which traverses a domain hierarchy and examines only the RFC 1101 proposed records;

siteinfo, which performs various types of domain name service queries to accumulate information about a site.

A source code distribution of domtools is available. The requirements for installation include dig, BIND 4.8.3 or newer, Perl 4 or newer, and Gawk. The documentation is contained within several ASCII text files.
[http://www.domtools.com/dns/]
DONLP2: An implementation of a technique for regularizing inconsistent quadratic programming (QP) problems. The method is a sequential equality constrained QP method (with an active set technique) with an alternative usage of a fully regularized mixed constraint subproblem in case of nonregular constraints (i.e. linear dependent gradients in the working set). This uses a slightly modified version of the Pantoja-Mayne update for the Hessian of the Lagrangian, variable dual scaling, and an improved Armijo-type stepsize algorithm. Bounds on the variables are treated in a gradient-project like fashion. This program is written in Fortran 77. See () and ().
[ftp://elib.zib.de/netlib/opt/donlp2/]
Dore: The Dynamic Object Rendering Environment is a powerful graphics library which enables the production of both dynamic image sequences and near-photographic quality images. Dore allows a user to combine the generation of full-color, high-resolution 3-D images with computationally intensive applications in such fields as molecular modeling and fluid dynamics. It was designed for ease of use, to be interactive, to support multiple output devices and renderers, and to be portable to several platforms.
Dore provides a comprehensive set of tools for creating graphics applications including:

geometric primitives such as polygons and patches for representing objects;

advanced primitives such as polygonal meshes, closed cubic surfaces, and nonuniform rational B-spline surfaces;

surface properties such as ambient, diffuse, and specular light reflectance as well as transparency, shadows, and environmental reflection;

features for the description of graphics scenes which include objects, the lights used to illuminate them, and the cameras used to view them;

various rendering representations including points, wireframe, faceted, and smooth-shaded surface types as well as combinations of styles in the same scene;

and a wide array of functions which enable the editing of the graphics database.

Dore has interfaces and drivers to X11, PEX, IrisGL, OpenGL, PostScript, and more.
A source code distribution of Dore is available. It has been ported to most UNIX systems including Linux. It is extensively documented in separate developer's, system, and programmer's guides as well as in a reference manual, all of which are available in PostScript format. It is also documented in a set of man pages.
[http://sunsite.unc.edu/pub/packages/development/graphics/Dore/]
DOSEMU: A PC emulator application that allows Linux to run a DOS operating system in a virtual x86 machine. This allows you to run many DOS programs including some DPMI applications. This is far from a completed project, but still farther along than the similar WINE project. The Nov. 1995 issue of the Linux Gazette has an article entitled ``Introduction to DOSEMU'' by Alan Bailward. The current (3/98) stable version is 0.66.7 (which runs with the 2.0.x/2.1.x Linux kernel) and the current development version is 0.97.4.
[http://www.dosemu.org/]
DOSLINUX: A version of Linux that can be dropped into any DOS system, e.g. OpenDOS, MS-DOS, PC-DOS, Novell, and Windows 95 in DOS mode. It is primarily intended as a way to have outgoing SLIP/PPP networking under a DOS system. The DOSLINUX kernel has math coprocessor support for CPUs without one and requires at least a 386 CPU to run Linux. It was compiled with support for IDE and SCSI hard drives, but doesn't have X11 or any programs needed for compiling, e.g. the gcc compiler There are compiled ELF versions of these programs which can be dropped into the system as well as instructions on how to get and install X11 on it.
[http://www.tux.org/pub/people/kent-robotti/]
[ftp://gwyn.tux.org/pub/people/kent-robotti/doslinux/]
Dotfile Generator: See TDG.
doubledouble: A C++ library which implements doubled-double (approximately 30 decimal places) floating point arithmetic on IEEE 754 floating point hardware. This will also work on the Pentium architecture since the control word is manipulated to override the effect of double rounding. The speed penalty is about a 10 to 25 times slowdown compared to double precision. The available documentation for doubledouble is on the web site.
[http://www-epidem.plantsci.cam.ac.uk/~kbriggs/doubledouble.html]
DOUG: The Domain decomposition On Unstructured Grids package is a black box parallel iterative solver for finite element systems arising from elliptic partial differential equations. DOUG will, when used in conjuction with a finite element discretization code, solve the resulting linear systems using an iterative method and provides a range of powerful domain decomposition preconditioners. It is designed to run efficiently in parallel on any machine that supports MPI. The source code is available as is the documention in HTML and PostScript format.
[http://www.bath.ac.uk/~masmjh/]
doxygen: A documentation system for C and C++ that can generate an online class browser in HTML and an offline reference manual in LaTeX from a set of documented source files. It can even be configured to extract the code structure from undocumented source files. The features include:

very little overhead required from the source code writer;

allows documentation of files, classes, variables, functions, typedefs, enums and defines;

includes a full C preprocessor for proper parsing of conditional code fragments;

automatic detection of public, protected and private sections;

generation of hierarchically structured documentation;

automatic generation of references to base classes and inherited members;

a fast, rank-based search engine;

automatic conversion of HTML tags in documentation to LaTeX;

references to documentation of other projects in a location independent way;

inclusion of source code examples that are automatically cross-referenced with the documentation; and

a configuration file from which all options are read.

A source code distribution is available which requires Qt and Perl for compilation and use.
[http://www.stack.nl/~dimitri/doxygen/]
DP: A logic programming system which controls symbolic inferences using general heuristics based on dynamics. Programs written in DP resemble those in Prolog although computation doesn't always proceed on a top-down and left-to-right basis. Information flow is implicit and computation proceeds along various directions depending upon context, i.e. DP deals with the whole logic program as a constraint. The declarative semantics of a program are expressed by capturing the degree of violation of constraint in terms of potential energy. This gives rise to a dynamical situation which controls computation to process only important information. DP programs create heterarchies consisting of various constraint modules.
A source code distribution of DP is available which contains three versions of DP. One version is written in C and can be compiled on generic UNIX systems. A user's guide is included in LaTeX format. This is part of the ICOT project.
[http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/-areas/icot/kbms_clp/unix/]
DPMTA: The Distributed Parallel Multipole Tree Algorithm library provides applications with a flexible implementation of numerous multipole algorithms to efficiently compute N-body interactions for a wide variety of system sizes and particles. Fast multipole algorithms (FMAs) are for the numerical solution of the N-body problem, which involves computing the net effect of the interactions of each pair of particles out of a set of N. In molecular dynamics the particles are atoms and the forces electrostatic while in astrophysics the particles are stellar bodies and the forces gravitational.
Brute force, naive algorithms for calculating these interactions require an amount of computation that grows as the square of the number of particles. The FMA process uses multipole expansions (MPEs) to represent the effects of a group of particles on a single entity. This reduces the amount of computation required to an almost linear function of the number of particles. The DPMTA package also includes another tree-based algorithm similar to FMA as well as the PMTA algorithm which combines parts of both preceding algorithms.
DPMTA is written using the PVM distributed computing toolset and thus runs on all platforms on which PVM can be installed, i.e. a very large range of platforms. The documentation is contained in 24 page user's manual in PostScript format.
[http://www.ee.duke.edu/Research/SciComp/software.html]
DPS: See Display PostScript.
DPWT Toolbox: The Discrete Periodic Wavelet Transform Toolbox is a set of Matlab scripts for experimenting with the discrete periodic wavelet transform and its inverse. It is documented in a couple of technical reports available at the site.
[http://www.InversionInc.COM/wavelet.html]
DQS: The Distributed Queueing System is a management tool to aid in the distribution of computational resources across a network. DQS provides architecture transparency for both users and administration across a heterogeneous network, allowing for the seamless interaction of multiple architectures. It is highly customizable to fit specific site needs.
DQS includes many useful features including:

Qmon, a GUI for DQS based on X/Xt which displays the status of various processes and allows commands to be issued;

Qusage, an accounting utility featuring online help and PostScript output;

Qconf, a GUI configuration utility for configuring queue complexes, clusters, queues, managers, hosts, and users;

Qstat, which shows qstat options; and

Qsub, to build the qsub command for submitting jobs.

It uses the DMake parallel make utility and supports PVM. The new features of the latest (3.0) version include:

increased fault tolerance;

the use of queue-complexes (i.e. arbitrary resource definitions that can be associated with queues to determine a best fit between requested and available resources);

greater flexibility in user submission scripts;

compile-time option matrices which allow the inclusions or exclusions of various features at compile time;

support for DFS/WAN in addition to AFS; and

better interactive support.

A source code distribution of DQS is available. It is written in C and includes an installation system that configures everything and walks you through the setup and installation procedures. The documentation includes an installation and maintenance manual, a reference guide, a user's guide, and a guide to error messages, each of which is available in ASCII and HTML format.
[http://www.scri.fsu.edu/~pasko/dqs.html]
dQUOB: The dynamic QUery OBjects package is a compiler and run-time environment used to create computational entities called quoblets that are inserted into high-volume data streams. This allows the specification of application-specific queries for controlling the data flow, i.e. queries that examine the flow and make decisions prior to computations being performed. The coupling of queries and computations increases the decision making capabilities of a computational entity, and also serves to increase the scalability of the entire data flow. The logical architecture of the system consists of:

a compiler that accepts, compiles, and optimizes queries to create event-action rules, and a back-end to transform the rules into scripts;

a run-time environment consisting of a library for building compile-code objects from scripts, an interpreter to execute the scripts, a reoptimizer to apply more run-time optimizations, and a quoblet run-time to control it all.

The capabilities of the dQUOB system include:

capturing data stream characteristics and adapting rules and rule management at runtime in response to detectable patterns of change;

specifying complex (primarily temporal) queries that join over any number of event types arriving from distributed sources, resource monitors, data or clients; and

an integrated adaptability policy based on database query optimization techniques.

The full dQUOB release is not yet (11/00) available, although a partial source release of the quoblet run-time environment can be downloaded. The code is written in C++ and the script interpretation part in Tcl/Tk.
[http://www.cc.gatech.edu/systems/projects/dQUOB/]
DragonRay: A ray tracing engine similar to POV-Ray in design. DragonRay implements basic objects, lighting, textures, platform independence, parallelism, and more. A source code distribution is available.
[http://www.cs.utk.edu/~rothrock/dray/]
Drat: A C++ interface to the Ncurses library which is not simply a wrapper but is intended to allow object-oriented programmers to quickly develop curses-based user interfaces. Drat encapsulates many of the awkwawrd bits of the curses library within a common interface, e.g. positions are specified consistent with other window schemes, the same methods are invoked regardless of which window is involved, and many common tasks such as prompting or retrieving a line of input have been incorporated into the interface. It includes form-based clases to handle some common interface tasks including menus, input forms, and output forms. These classes allow callbacks to be registered with form items which allows the data and methods associated with input processing to be encapsulated within a class.
A source code distribution of Drat is available. It is written in C++ and has been successfully compiled using gcc 2.7.0 or greater. The documentation is thus far (6/97) a bit sketchy.
[http://www.best.com/~smurman/Drat]
DRAWxtl: A program which creates and displays crystal structures in two forms, i.e. VRML and POV-Ray. The VRML form can be viewed locally or across the Internet with the viewer capable of rotating and zooming the drawing in real time. The POV-Ray form is equivalent to the original, non-rotated and non-zoomed version and intended to create high resolution pictures for publication. DRAWxtl can make ball-and-stick diagrams with either spheres or thermal ellipsoids, with the capability of inputting anisotropic coefficients in different ways. It can also make polyhedral diagrams with polyhedra of any desired shape. It can read structural input from CIF, CSD, GSAS, SCHAKAL and SHELX formats as well as its native format.
A source code distribution of DRAWxtl is available as are binaries for various platforms including Linux Intel.
[http://granite.ciw.edu/~finger/DRAWxtl.html]
DRI: The Direct Rendering Infrastructure is a framework for allowing direct access to graphics hardware in a safe and efficient manner. It includes changes to the X server, several client libraries, and to the kernel. The first major use of this was to create fast implementations of OpenGL for use with such 3-D graphics cards as Voodoo3/Banshee. The DRI code will be included in XFree86 4.0, and the developers have agreements with 3dfx, Intel, ATI and Matrox to develop open source 3-D acceleration under Linux.
[http://dri.sourceforge.net/]
drivers/device drivers: Many drivers for sound, video, SCSI and other types of cards are available for Linux.
Sound drivers include:

ALSA, a modularized sound driver project;

AudioFile, a network-transparent audio server and client library including drivers for several devices;

Aureal, a driver for sound cards based on the Vortex PCI sound chips;

awe, for the Soundblaster AWE32/64 cards;

emu10k1, for the Soundblaster Live card;

OSS, sound drivers for Linux; and

SkySOUND, a project to build a stream-oriented audio library.

Video and graphics device drivers include:

bttv, a driver for Brooktree Bt848-based frame grabbers;

DRI, a framework for implementing direct access to graphics hardware in a safe and efficient manner;

GAL, a domain-specific language for describing video device drivers;

GATOS, a project to create standard drivers for all currently supported features of ATI video cards;

GGI, a project to develop a standard architecture for graphics hardware device drivers and their OS interactions;

3dfx, a 3Dfx Banshee/Voodoo3 driver;

Utah-GLX, a hardware accelerated version of the GLX protocol for Linux platforms;

Video4Linux, a set of drivers and programs providing a common API to video and tuning sources;

Voodoo Graphics, a driver for Voodoo Graphics based graphics accelerators;

Voodoo Rush, a driver for Voodoo Rush graphics cards;

Voodoo3/Banshee, a driver for Voodoo3 and Voodoo Banshee graphics accelerators;

Voodoo2, a driver for Voodoo2-based graphics cards;

wacom, a driver for Wacom digitizing tablets for XFree86.

Ethernet and RAID drivers include:

DAC960, a driver for DAC960 PCI RAID controllers;

GAMMA, a custom device driver for 100baseT network cards under Linux;

smart2, a driver for Compaq Smart-2 disk array controllers;

3c59x, a package of drivers for various 3Com-based cards; and

3c90x, a package of drivers for various 3Com-based cards.

Drivers for tape and floppy drives include:

fdutils, utilities for configuring and debugging the Linux floppy driver; and

ftape, a driver program for various low cost tape drives that connect to the floppy controller.

File system drivers include:

BFS, a Linux driver for the BeOS filesystem;

EXT2-OS2, a driver for the OS/2 filesystem;

hfs-fs, a driver implementing the Mac HFS filesystem;

NTFS, a driver for the NT filesystem; and

u2fs, a driver for providing UFS filesystem support.

Scanner drivers include:

mtekscan, a driver for MicroTek ScanMaker SCSI scanners; and

SANE, a universal scanner interface.

Miscellaneous drivers include:

bitbus4linux, drivers for a specialized fieldbus for industrial applications;

CAMAC-Linux, a package of CAMAC device drivers

can4linux, drivers for a CAN development environment;

Card Services, drivers that implement to PCMCIA 2.1 Card Services API;

CIPE, a driver to implement encryption for IP routers;

COMEDI, drivers for implementing data acquisition hardware that performs A/D conversions;

CompactNET, a multiprocessing system for applied computing applications in the communications and automation industries;

Console Tools, a package for customizing consoles that includes a console driver consisting of keyboard and screen drivers;

isdn4linux, drivers for implementing ISDN;

joyd, a driver that allows any command to be triggered via a joystick;

LDDK, a toolkit for the development of hardware drivers for Linux systems;

Linux-GPIB, a driver and user interface package for a wide range of GPIB cards;

MR Toolkit, a package containing device drivers for virtual reality devices;

OSKit, an OS development system including components for developing device drivers;

SampLin, drivers for various scientific data acquisition hardware;

ss5136dn, drivers for cards that perform industrial automation applications; and

vmehb, a loadable device driver for accessing VME bus spaces.

See Rubini (1997) for an overview on writing device drivers.
Drone: A tool for automatically running batch jobs of a simulation program, allowing sweeps over arbitrary sets of parameters as well as multiple runs for each parameter set with a separate random seed for each run. The runs may be executed either on a single computer or over the Internet on a set of remote hosts. Drone was originally designed for use with the Swarm agent-based simulation framework, but can be used with any simulation program which reads parameters from the command line or an input file.
Drone is written in Expect, a Tcl/Tk extension. The former but not the latter must be installed to use Drone. A user's guide for Drone is available in DVI, PostScript and HTML format.
[http://pscs.physics.lsa.umich.edu/Software/Drone/doc/drone.html]
DRP: The Distribution and Replication Protocol is for improving the efficiency and reliability of data distribution over HTTP. It was designed to efficiency replicate a hierarchical set of files to a large number of clients. The data can consists of any kind of code or content with the protocol providing strong guarantees about data versioning. Content identifiers are used to automatically share resources requested more than once. The meta data is described using a data structure called an index which is specified using XML.
[http://www.w3.org/TR/NOTE-drp-19970825.html]
[http://www.marimba.com/faq/drp-faq.html]
DRS: The Data Retrieval and Storage library and utilities define a storage format and access methods suitable for the data generated and analyzed in climate model research. It is oriented toward use with models generating very large datasets. The features include:

support for multi-dimensional array variables;

subsetting and data reordering operations;

direct access I/O and access by coordinate ranges;

machine-independent storage format;

support for Cray native mode format;

C and Fortran APIs; and

an interactive data browser utility.

A source code distribution is available. It is written in C and Fortran. Documentation includes user's and utilities manuals in PostScript format.
[http://www-pcmdi.llnl.gov/drach/DRS.html]
DrScheme: A Scheme development environment with project management and debugging tools. The features include source text highlighting of syntax and run-time errors, simple program analysis to prevent common syntax errors, a project manager to support multi-file Scheme programs, interactive and graphical static analysis, Scheme language extensions including primitive graphics utilities, and more. Planned extensions include support for an object system and a full GUI library and execution monitoring tools. This is available in source form or as a binary for several different platforms, including Linux (in a.out format). The documentation includes a user manual in several different printable formats.
[http://www.cs.rice.edu/CS/PLT/packages/drscheme/index.html]
DR3M: The Distributed Routing Rainfall-Runoff Model II is a watershed model for routing storm runoff through a branched system of pipes and/or natural channels using rainfall as input. It is usually used to simulate small urban basins. DR3M provides a detailed simulation of specified storm-runoff periods. It features a daily soil moisture accounting between storms and represents a drainage basin as a set of overland flow, channel, and reservoir segments which jointly comprise the drainage features of the basin. It does not simulate interflow, base flow, snow accumulation, or snowmelt.
DR3M accounts for several rainfall-excess components including soil moisture, pervious-area rainfall excess, impervious-area rainfall excess, and parameter optimization. The Green-Ampt equation is used in the calculations of infiltration and pervious area rainfall excess, with a Rosenbrock optimization procedure used to aid in calibrating several of the infiltration and soil moisture accounting parameters. Kinematic wave theory is used for both overland flow and channel routing. Three solution techniques are provided including the method of characteristics and implicit and explicit finite differences. Two soil types can be defined and overland flow can be defined as turbulent or laminar. Detention reservoirs can be simulated as linear storage or via a modified-Puls method, and channel segments can be defined as gutter, pipe, triangular cross-section, or by explicitly specifying the kinematic channel parameters.
A source code distribution of DR3M for UNIX platforms is available. The primary documentation is contained within Alley and Smith (1982). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/dr3m.html]
[http://www.geogr.uni-jena.de/software/dr3m.html]
Drumachine: A program which translates a simple drum pattern description file into a Csound score. It supports time-variable volume and tempo changes. The distribution contains the source code and a Linux Intel executable version of Drumachine. It also contains a selection of drum samples and a manual.
[http://tobiah.rcsreg.com/pub/drumachine/]
DSC: The Distributed Symbolic Computations system is an environment for the distributed processing of coarse grained computations, i.e. a set of programs and conventions for implementing parallel algorithms on conventional computers with conventional operating systems and conventional high level languages. It supports the distribution of code written in any of four languages, i.e. C, C++, Lisp and Maple.
DSC consists of two daemon programs which execute on each participating node on a TCP/IP network; an interactive program to start and monitor task programs; C, Lisp and C++ program modules which must be built into any application target problem programmed into any of these languages; higher level Lisp and C++ library functions; and Maple program interface modules and daemons.
DSC is designed to compile and run on generic UNIX workstation environments (and will compile with gcc). The distribution includes the C source, several example programs, some network utilities, and a user's guide in PostScript format. It has been tested on Sun SPARC and DEC Ultrix platforms.
[ftp://ftp.cs.rpi.edu/pub/dsc/]
DSE: The Dynamic Systems Estimation library is a collection of R programs designed for estimating and converting among various represenatations of time series models. DSE is useful for studying the statistical implications of equivalence among different model representations, studying the small sample properties of estimators, and studying the forecasting properties of models. The library works with linear, time-invariant ARMA, state space (SS) and troll models, and it written such that other model representations can be added. The functions in the library include those for:

calculating the McMillan degree of a model;

checking the stability of a model;

simulating a model to generate artificial data;

evaluating an SS or ARMA model with data;

calculating the smoothed state for a state space model;

estimating VAR models with exogenous variables using either OLS or autocorrelations;

estimating VARX models and converting to state space;

estimating state space models using Mittnik's Markov parameter technique;

maximum likelihood model estimation;

nested-balanced state space model reduction via SVD;

generating a forecast from given model and data;

forecasting from specified periods for specified periods ahead; and

calculating covariance of multi-period ahead forecasts.

A source code distribution is available.
[http://www.bank-banque-canada.ca/pgilbert/dse/dsedesc.htm]
dsniff: A suite of utilities for the penetration testing of a UNIX computer. The programs included are:

arpredirect, intercepts packets from a target host (or all hosts) on an LAN that are intended for another host on the LAN by forging ARP replies;

findgw, determines the local gateway on an unknown network via passive sniffing;

macof, floods the local network with random MAC addresses to cuase some switches to fail open in repeating mode;

tcpkill, kills specified in-progress TCP connections;

tcpnice, slows down specified in-progress TCP connections via ctive traffic shaping;

dsniff, a simple password sniffer that minimally parses a large number of application protocols to save only the interesting parts;

mailsnarf, gets all messages sniffed from SMTP traffic in mbox format;

urlsnarf, outputs all requested URLs sniffed from HTTP traffic in Common Log Format; and

webspy, sends URLs sniffed from a client to a web browser for a display that's updated in real time.

[http://www.monkey.org/~dugsong/dsniff/]
dsp library: This is a library of digital signal processing programs written in Fortran. It includes subroutines for FIR and IIR filter design, FFT routines, and various other programs for signal processing. Since the home site for this package is notoriously intermittent and their package is compressed using the ZIP software, I've made it available here in a file named dsp.tar.gz.
[ftp://nimios.eng.mcmaster.ca/pub/IEEE/software]
DS++: A library of C++ classes which implement a variety of data structures which makes significant use of templates to enable the client to have data structures of any user defined class. The author's intention is to do something about the complete lack of a standard set of classes for C++, i.e. most C++ libraries that exist are commercial and many compiler vendors don't supply any classes. The g++ classes are available but the compiler isn't on machines like the Cray. This led to the creation of a class library of generally useful data structures for C++. The author does recommend that if you have access to STL you should use it instead.
The classes include:

Array, a bounds-checked templated array class;

DynArray, a dynamically growable templated array class;

DynTable, an autoexpanding row/column container;

Islist, an intrusive singly linked list;

Islist_iter, an iterator for an Islist;

Map, an association array class;

Map_iter, an iterator for Map;

SArray, a simple array class;

SP, a templated smart pointer class;

Slist, a templated singly linked list class;

Stack, a templated unbound stack class; and

String, a string class.

The source code to DS++ in compilable by both Cfront and g++. The classes are documented in man pages and in a brief FAQ included with the distribution.
[http://dino.ph.utexas.edu/~furnish/ds++/ds++.html]
DSR: The Dynamic Source Routing protocol is one designed specifically for use in mobile ad hoc networks. it allows nodes to dynamically discover a source route across multiple network hops to any destination in the ad hoc network. An implmentation of this is included in the CMU Extended NS package.
[http://www.ietf.org/internet-drafts/draft-ietf-manet-dsr-03.txt]
DSSSL: The Document Style Semantics and Specification Language is an international standard for associating processessing with SGML documents, i.e. it can be used to describe the processing of documents in a standard way. The first two types of document processing standardized by DSSSL were formatting and transformation.
The parts of the DSSSL standard are:

the style language, a standardized, powerful language for describing the formattaing of SGML documents, i.e. a DSSSL processor implementing the language will take an SGML document (with DTD) and a stylesheet and either create a formatted document (in whatever formats it supports) or immediately display the formatted result;

flow objects, a standard mechanism for describing the layout of a document which represents layout constructs such as page sequences, paragraphs, hyperlinks, etc.;

the transformation language which is a standard language for transforming SGML documents marked up according to one DTD into another;

the document model which describes a document or a set of documents as nodes organized into a grove, i.e. trees of trees; and

the query language which is for selecting and returning document components in a manner similar to SQL selecting and returning a particular element from a database.

A freely available DSSSL processor is Jade. See also the DSSSL Page of James Clark.
DsTool: A computational environment the provides a tool for exploring dynamical systems. It integrates a GUI, data management, a set of numerical algorithms with a capability of adding more, and the capability of communicating with other programs. It was developed for the X Window system and the original port was to Sun platforms, although it supposedly can be ported to any platform for which a port of the XView library has been made, a list of which is available in the indicated directory. The documentation says that it has been ported to a Linux platform.
[ftp://macomb.cam.cornell.edu/pub/dstool/]
DSU: Distributed Seismic Unix is a package designed to assist geophysicists in developing and executing sequences of SU applications in clusters of workstations as well as on tightly coupled multiprocessor machines. DSU is built on top of SU, the TclTk toolkit and GUI development package, and the PVM software that supports multiprocessing. DSU provides tools for creating, editing, setting parameters, saving on plain ASCII files, and executing SU application sequences over several types of multiprocessor environments.
The source code of the DSU package is available and should readily install on any UNIX platform on which SU, PVM, and Tcl/Tk can also be installed which, given the portability of all of the above, is quite a few platforms. The documention for DSU is available in both HTML and PostScript formats.
[http://landau.mines.edu/pvm]
DSYT: A Fortran 77 implementation of a lookahead Levinson algorithm for solving symmetric indefinite and general Toeplitz systems. The algorithms are numerically stable for all Toeplitz matrices that do not have many consecutive ill-conditioned leading principal submatrices. They also produce estimates of the algorithm and matrix condition numbers. This is TOMS algorithm 729 and is documented in Hansen and Chan (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
DTDParse: A program that reads an SGML DTD and constructs a simple, easily-parsed database containing its content. The database can then be read to construct other views of the DTD. This two step process is used to simplify and speed up the subsequent processing. The package contains scripts for extracting information from the DTD database including:

parents, lists the parents of a given element;

children, lists the children of a given element;

dtd2man, produces DocBook RefEntry pages (aka UNIX man pages) for the components of the DTD; and

dtd2html, builds a set of linked HTML pages of the components of the DTD.

A source code distribution is available. It is written in Perl and requires version 5.003 or later.
[http://www.ora.com/homepages/dtdparse/]
[http://nwalsh.com/perl/dtdparse/]
DTK: The Deception ToolKit is designed to give defenders of computers an advantage over attackers. DTK uses deception to counter various types of attacks, with the deceptions intended to make it appear to attackers that a system has a large number of widely known vulnerabilities. The functionality is typically limited to producing output in response to attacker input in such a way as to simulate the behavior of a system that is vulnerable to the method being used by the attacker. This method serves to both increase the workload of attackers and allow tracking and responding to attack attempts. The features include:

optionally compressed log files and a program to expand them;

timeouts and limits on inputs everywhere so resource exhaustion is defended against; and

built-in detection of reporting of port scanning.

The current (8/99) components of DTK include:

generic.pl, a generic interface that works with TCP wrappers to service incoming requests;

listen.pl, a port listener that forks slave processes to handle each inbound attempt;

logging.pl, for logging attack attempts;

respond.pl, for responding based on a response config file;

notify.pl, for notifying administrators of known attacks;

coredump.c, produces a phony coredump message on a port;

[nn].response, a responder finite state machine for each port; and

fake.passwd, a fake password file that can't be decoded.

A source code distribution is freely available for non-profit users.
[http://all.net/dtk/dtk.html]
DTM: The Definitive Type Manager is a collection of Perl scripts for installing fonts and configuring applications to use them. A DTM database manages the fonts and supplies information to the application hooks responsible for the configuration of various applications (e.g. Ghostscript, enscript, X11, GNOME and TeX). Information about the fonts is supplied in the form of text files called catalog snippets. Various utilities to automatically generate files are provided. A source code distribution is available.
[http://www.debian.org/~fog/dtm/]
DT_NURBS: A spline geometry subroutine library used by the David Taylor research center. DT_NURBS uses a non-uniform rational B-spline (NURBS) representation for general spline functions and is implemented in Fortran 77. The principal motivation for creating this library was the need for a toolkit for building interfaces between the many design and analysis tools used in the development of complex physical systems like ships and airplanes. Another motivation was to help establish standard representations for geometric design and related analysis data which are not dependent on the peculiarities of any particular tool.
Although the NURBS representation is most often used to express curves in a plane or curves and surfaces in space, the underlying mathematics work equally well for n-parameter functions in m-dimensional space. DT_NURBS was designed to support these more general functions, which allows it to be used to represent functions with arbitrary numbers of independent and dependent variables. Examples include modeling a surface along with the pressure and temperature at each surface point as a single NURBS object, the ability to model a time-varying surface as a three-parameter NURBS object, the ability to model fluid flows in a volume as a single continuous NURBS function, and the ability to create, manipulate, and analyze all these things with the same set of tools. DT_NURBS also includes facilities which mitigate the shortcomings of Fortran 77 in regards to creating complex data structures and dynamically allocating memory based on run-time needs while still remaining fully compliant with the Fortran 77 standard.
The DT_NURBS library is available in a source code distribution upon submitting an email request stating what will be done with the library and various other information. Documentation includes user's, reference, and theory manuals as well as several technical papers, all available in several formats.
[http://ocean.dt.navy.mil/dtnurbs/dtnurbs.htm]
Duel: A high-level C debugging language extension to gdb. It is designed for the concise state exploration of debugged C programs and invoked by entering the shell command duel rather than gdb. According to the authors, Duel stands for either Debugging U (might) Even Like or Don't Use (this) Exotic Language. See also the xduel interface package.
[ftp://ftp.cs.princeton.edu/pub/packages/duel/]
dump: The dump and restore utilities for the ext2fs filesystem. The dump program determines which files need to be backed up, and then copies them to a specified disk, tape or other storage medium. The restore command inverts the functionality of dump, i.e. it can restore a full backup of a filesystem. It can also restore single files and directory subtrees from full or partial backups in interactive mode.
[http://dump.sourceforge.net/]
DUSTY: A Fortran code for solving the astrophysical problem of radiation transport in a dusty environment. The features of the code include:

handling both spherical and planar geometries;

calculation of the dust temperature distribution and radiation field;

a solution method based on a self-consistent equation for the radiative energy density including dust scattering and absorption (that doesn't introduce any approximations);

built-in optical properties for the most common types of astronomical dust as well as a library for many other grain types;

support for various analytical forms of the density distribution;

a full dynamical calculation for radiatively-driven winds around AGB stars;

analytical specification of the spectral energy distribution of the source as either Planckian and broken power law;

specification of arbitrary dust optical properties, density distributions and external radiation; and

modification of the wavelength grid to accomodate spectral features.

A manual is available in PostScript, PDF or LaTeX source format. This is part of the ASCL collection. See Miroshnichenko et al. (1999).
[http://ascl.net/dusty.html]
[http://www.pa.uky.edu/~moshe/dusty/]
dvgt: A previewer for TeX DVI files using ttys and SVGAlib.
[http://sunsite.unc.edu/pub/Linux/apps/tex/dvi/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/tex/dvi/]
dvi: A device independent file is the standard output format of the TeX typesetting program. It contains the formatted text along with information about the required character fonts, all in a form that is independent of the printer to be used for printing the document. The dvi file is transformed into a form amenable to printing via the use of any of several available printer drivers, the most common of which is probably the dvips program which converts the dvi file into a standard PostScript file. The CTAN dviware directory contains printer drivers for many types of printers, many of which are wholly obsolete.
dvipdfm: A TeX DVI to PDF translator whose features include:

use of TeX special commands that approximate the functionality of the PostScript pdfmarks for, e.g. support for links, outlines, articles and named destinations;

including PDF and JPEG files as embedded images;

support for both Type 1 and PK fonts;

arbitrary linear graphics transformations, i.e. scaling and rotating;

a color stack;

partial font embedding and stream compression;

limited portable graphics via TPIC commands; and

balanced page and destination trees for improved reader access on large documents.

Source and binary distributions are available for Linux platforms.
[http://odo.kettering.edu/dvipdfm/]
dvips: The de facto standard program for converting a TeX dvi file into a PostScript file for printing or distribution. The dvips program generates standard PostScript which can be included in other documents as figures or printed through a variety of spoolers. It allows PostScript graphics to be included in documents and scaled and positioned in a variety of ways. Printers with resolutions of 300 dpi and greater are supported, as is very high resolution output for typesetters (with an option for compressing bitmapped fonts to conserve virtual memory). Missing fonts can be automatically generated if Metafont is available, and if a font cannot be generated a scaled version of the same font at a different size can be used.
Additional features of dvips include:

collated copies and support for tpic, psfig, emtex and Metapost;

support for multiple printers (each with their own configuration file) and automatic piping of output directly to a program such as lpr; and

support for virtual fonts to provide PostScript font support, with the font remapping handled in a natural, portable, elegant, and extensible way, with the driver even having its own afm2tfm program which can create the necessary virtual fonts and TeX font metric files from the Adobe font metric files.

A source code distribution of dvips is available. It is written in C and portable to most UNIX flavors as well as to other OS types. It is documented in a user's manual available in PostScript format. The standard teTeX distributions include the most recent version of dvips and is probably the best way to obtain this if you don't want to compile it.
[http://www.radicaleye.com/dvips.html]
DVMRP: Distance Vector Multicast Routing Protocol is an Internet routing protocol providing an efficient mechanism for connection-less datagram delivery to a group of hosts across an internetwork. It is a distributed protocol that dynamically generates IP Multicast delivery trees using a technique called Reverse Path Multicasting (RPM).
[http://search.ietf.org/internet-drafts/ draft-ietf-idmr-dvmrp-v3-07.txt]
[http://www.faqs.org/rfcs/rfc1075.html]
DVS: The Distributed Versioning System is a simple versioning system based on NUCM. DVS uses a linear versioning schema and a cooperation policy based on check-in/check-out with exclusive locks. Single artifacts and directories can be maintained. Binary versions of DVS are available for several systems including Linux Intel. It is documented in a tutorial and a man page.
[http://www.cs.colorado.edu/serl/cm/dvs.html]
dxpc: The Differential X Protocol Compressor is a program designed to improve the speed of X11 applications run over low-bandwidth links such as dial-up PPP connections. The performance varies quite a bit depending on the application you're running.
[http://ccwf.cc.utexas.edu/~zvonler/dxpc/]
Dylan: A object-oriented programming language. A concise description (liberated verbatim from the Gwydion Dylan site): ``Dylan is an advanced, object-oriented, dynamic language which supports the rapid development of programs. When needed, the programmer can later optimize programs from more efficient execution by supplying type information to the compiler. Nearly all entities in Dylan (including functions, classes, and basic data types such as integers) are first class objects. Additionally, Dylan supports multiple inheritance, polymorphism, multiple dispatch, keyword arguments, object introspection, and many other advanced features.'' The salient features of Dylan include:

an advanced object model that is more powerful than those found in most mainstream languages;

useable as either a dynamic prototyping language or an efficient compiled language;

support for advanced IDEs, e.g. automatic storage of code in a database with multiple views of how definitions are related; and

infix syntax (i.e. like that of C).

Implementations of Dylan include:

Gwydion Dylan

Marlais and

Thomas.

[http://www.gwydiondylan.org/]
Dynace: The DYNAmic C language Extension is an object-oriented extension to the C programming language which was created to solve several perceived problems in C++. Dynace is more backward compatible with C and offers stronger object-oriented facilities than does C++. It is a preprocessor, include files, and a library which extends C with object-oriented capabilities similar to those found in CLOS and Smalltalk. These include multiple inheritance, true dynamic binding, a metaobject basis from the ground up, a class library, automatic garbage collection, and multiple threads. The strong encapsulation features allow classes located in the middle of a class hierarchy to be modified without having to recompile related classes.
A source code version of Dynace is available. It is written in C and portable to 16 and 32 bit DOS, Windows 3.1/NT/95, Mac, VMS, Linux, Sun SunOS and several other UNIX flavors. It is documented in a user's manual available in PostScript format. The package is freely available for non-commercial use.
[http://server1.florida-software.com/algorithms/]
Dynamic Java: A Java source interpreter that not only executes programs written in Java but also includes additional scripting features. This supports all features provided by the Java language and the Java 2 platform API including class and inner class definitions, multi-threading and garbage collection. This allows it to be used as an extensionlanguage, a debugging tool, for experimenting with a Java API, and as a rapid prototyping tool. The scripting extension features in Dynamic Java include:

writing statements and expressions outside of classes, i.e. in the top-level environment;

optional variable declarations and dynamic casts;

use of the package clause anywhere in the top-level environment to set the current package;

support for C-like functions in the top-level environment;

anonymous classes in the top-level can contain references to that environment's final variables; and

inline comments are allowed.

[http://www.inria.fr/koala/djava/]
[http://djava.sourceforge.net/]
Dynamic Probes: A generic and pervasive debugging facility that can operate under the most extreme software conditions, e.g. debugging a deep rooted operating system problem in a live environment. DProbes can be used to dynamically insert software probes into executing code modules. The features include:

placing probes almost anywhere, e.g. in any executable code including the kernel, even in interrupt handlers, kernel modules, etc.;

read access to all hardware registers and write access to most;

read/write access to any area in the virtual address space currently resident in physical memory;

probes placed in an executable program or shared library are globally active under the the context of all processes executing them; and

probes can be placed in programs being run under a debugger.

[http://oss.software.ibm.com/developerworks/opensource/linux/projects/dprobes/]
Dynamics: A package implementing scalable, dynamical and hierarchical Mobile IP for Linux. The features include:

secure signaling via standard RFC 2002 replay protection with timestamps and nonces, session keys and MD5 checksums for message validation, etc.;

scalability and fast localized location updates;

transparency, i.e. the illusion that the mobile host is directly connected (remotely) to a home network;

listening to multiple Foreign Agents in wireless LANs and making location update initiation decisions according to signal strength;

optimization of the location update procedure to guarantee minimal loss of data and short hand-off times;

efficient use of private networks wherein the entire Foreign Agent hierarchy (except the highest one) can be configured to use private IP addresses; and

various text-based administration and monitoring tools;

an API for building management and monitoring tools for users and administrators.

Dynamics is available as source code or as an RPM or DEB package. Extensive documentation is available in man page format.
[http://www.cs.hut.fi/Research/Dynamics/]
Dynamite: A language developed for the automatic generation of sequence comparison methods. It generates the dynamic programming methods that are used quite often in many aspects of sequence analysis.
[http://www.sanger.ac.uk/Software/Dynamite/]
DynAPI: An Open Source project to develop a cross-browser code library for programming DHTML. It includes many components for:

creating reusable widgets;

implementing scrolling;

creating select, scroll and menu lists;

creating dynamic windows;

creating clocks and calendars;

creating a news ticker; and

creating a collapsing menu.

Many more components are available and planned.
[http://sourceforge.net/projects/dynapi/]

[ home / linux ]

Next: Ea-Em Up: Linux Software Encyclopedia Previous: Da-Dm Contents

Manbreaker Crag 2001-03-08