Next: En-Ez Up: Linux Software Encyclopedia Previous: Dn-Dz Contents

Ea-Em

Last checked or modified: Dec. 13, 1999

E: A secure distributed object platform and scripting language for writing capability--based smart contracts. E defines and implements a pure object model of secure distributed persistent computation. It consists of two parts - a library and a language. The Elib library provides the functionality for communications between objects including:

object references that can span machines and persist while still remaining unforgeable;

message pipelining that results in significantly fewer network round trips;

a simple to use, deadlock-free, scheduling mechanism;

a Java API that enables stock Java objects to participate.

The E language is used to express what happens within an object. Its features include:

a Java shell that can be used to interactively call objects;

many of the conveniences of modern scripting languages, e.g. built-in pattern matching; and

object-granularity wherein an E object can interact with others only through Elib.

Source and binary distributions of E are available. It requires JDK 1.1 or above.
[http://www.erights.org/]
EA: The Evolving Algebra interpreter is an interpreter for evolving algebra written in Scheme. The features include:

a Scheme procedure corresponding to evolving algebra functions can be written and dynamically loaded into the interpreter;

dynamic loading of all or part of evolving algebra specifications; and

an interpreter with tools for creating profiles of the abstract use of resources.

A source code distribution is available as is a user's manual in PostScript format.
[http://www.cs.uit.no/~dagd/EA/]
EAG: A compiler compiler that uses the Extended Affix Grammar (EAG) formalism which describes both the context free and context sensitive syntax of language. The compiler generates either a recognizer or a transducer or a translator or a syntax-directed editor for a described language. A source code distribution is available that has been successfully used on Linux Intel systems. The formalism and compiler are described in a technical report available in PostScript format.
[ftp://hades.cs.kun.nl/pub/eag/]
EasyDTD: A program that creates an SGML DTD from a simple outline form of its data elements. EasyDTD is most commonly used for DTD prototyping and generating entity references. A source code distribution of this C program is available.
[ftp://ftp.ifi.uio.no/pub/SGML/EasyDTD/]
EasyMesh: A 2-D mesh generator which generates unstructured, Delaunay and constrained Delaunay triangulations in general domains. It will also handle holes in domains, local refining/coarsening, domains composed of more than one material, perform Laplacian smoothing, renumber nodes, elements, and sides, and more. It requires a simple ASCII file for input and creates ASCII output files.
EasyMesh is written in C and has been compiled and tested on PC/DOS, Linux, Sun SunOS, SGI IRIX, and Cray platforms. The documentation is contained within a set of HTML pages that accompany the distribution.
[http://www-dinma.univ.trieste.it/~nirftc/research/easymesh/]
EasySQL: A database-independent C/C++ SQL interface library. This thin layer between applications and databases allows any application to easy and transparently access any SQL server. It hides the details of the specific SQL database and also allows upgrading without recompilation. A source code distribution is available.
[http://www.amsoft.ru/easysql/]
Ecasound: A package designed for multitrack audio processing. Ecasound can be used for simple tasks like audio playback, recording and format conversion as well as for multitrack effect processing, mixing, recording and signal recycling. It supports a wide range of audio inputs, outputs and effect algorithms as well as several open source audio packages (e.g. ALSA, MikMod and libaudiofile). It uses a chain-based design that allows sounds and effects to easily be combined both in series and parallel.
The tasks for which Ecasound is especially suited include:

hard disk and multitrack recording and mixing;

effect procesing via a wide range of available effect algorithms;

real-time signal routing; and

audio file playback and format conversion.

The included interfaces and utility programs include:

ecasound, a console-based, textmode interface;

qtecasound, a Qt-based X11 interface that doesn't have as much functionality as ecasound;

ecatools_fixdc, a utility for fixing DC-offset;

ecatools_normalize, a utility for normalizing volume levels; and

ecatools_play, a utility that plays files using the default output.

[http://www.wakkanet.fi/~kaiv/ecasound/]

ecawave

A graphical sound file editor based on the ecasound library and the Qt GUI library.
[http://www.wakkanet.fi/~kaiv/ecawave/]
Echidna: A class library that allows multiple processes to run inside a single Java Virtual Machine (JVM). This is implemented in Java and allows all objects to live inside a single VM rather than spawning a separate VM for each application. The features include:

having large stable classes (e.g. core API and Swing) stay in the primordial namespace of the system while loading and unloading development classes;

determining which process is currently executing;

creating lightweight namespaces that give each process its own static-shared resources like standard I/O streams;

resource registration that allows processes to cleanly dispose of important resources when they are killed;

extended classpath capabilities that allow classes to be transparently loaded from any URL for which a protocol handler is available; and

per-process classpaths that allow each process to load classes from any source regardless of normal classpaths and the classpaths of other processes.

A source code distribution is available under the GPL.
[http://www.javagroup.org/echidna/]
Echo: A simulation tool developed to investigate mechanisms which regulate diversity and information processing in systems comprised of many interacting adaptive agents or complex adaptive systems (CAS). Echo agents interact via combat, mating and trade to develop strategies for ensuring survival in resource-limited environments. Individual genotypes are encodings of rules for interactions, and in a typical simulation populations of these genomes evolved complicated networks of interactions and resource flow. The resulting networks can be thought of as resembling species communities in real-world ecological systems. Changing parameters and initial conditions allows the exploration of a wide range of experiments.
The Echo software was developed on a Sun workstation but should be portable to generic UNIX boxes. The source code is available and is written in ANSI C. Compilation and use also require the installation of the FWF widgets, the Xaw library, and the Athena Plotter widget set. The package is documented in several technical reports and papers available in PostScript and/or HTML format. See Forrest and Jones (1994).
[http://www.santafe.edu/projects/echo/echo.html]
ECHOMOP: A Starlink Project package which provides facilities for the extraction of spectra from 2-D data frames, with the data being either single-order or multi-order échelle spectra. A variety of options are available for the reduction of the spectra data frames, ranging from full-scale automated reduction to step-by-step, order-by-order manually assisted processing. All the ECHOMOP facilities can be access from a single program called ECHMENU. There are over 30 tasks and menu options available for which over 160 different parameters can be modified.
The capabilities of ECHOMOP include:

spectral order location and tracing,

cosmic-ray removal,

detection of bad image rows and columns as well as saturated pixels,

determination of object channels,

generation of flat-field balance models,

modeling scattered light,

optimal spectrum extraction,

échell blaze correction,

quick-look spectral extraction,

automated location of lines and wavelength calibration of arc spectra,

distortion fitting for spectral orders,

extracted of distorted orders,

scrunching of extract spectral orders,

production of distortion-free images, and

plotting of data used for a reduction.

A binary distribution of ECHOMOP is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. It is documented in a 110 page user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
ECL/ECoLisp: ECoLisp or Embeddable Common Lisp is an implementation of Common Lisp designed for being embeddable in to C-based applications. It uses standard C calling conventions for Lisp compiled functions, allowing C programs to easily call Lisp functions and vice-versa. No foreign function interface is needed, i.e. data can be exchanged with no need for conversions.
[http://www.di.unipi.it/~attardi/software.html]
ECLiPSe: A development environment for constraint logic programming (CLP) applications. CLP is a method for attempting to solve especially tricky combinatorial problems encountered in such asreas a job scheduling, timetabling and routing, i.e. tasks that overextend more traditional solution techniques. It contains several constraint solver libraries and provides a high-level modeling language for the development of programs for solving various combinatorial problems.
The features of ECLiPSe include:

a attributed variable data type which greatly extends the basic logic programming language;

several constraint libraries including arithmetic constraints over finite atomic domains, finite set constraints, linear rational constraints, generalized propagation, interval reasoning over nonlinear constraints, repair-based search, etc.;

declarative and imperative coroutining facilities;

a fast incremental compiler;

program execution in or-parallel mode on shared memory multiprocessor hardware;

comprehensive synchronous (events) and asynchronous (interrupts) event handling;

configurable as a sound and complete solver for Horn programs;

a sophisticated predicate-based incremental module system;

backward compatibility with the Edinburgh family of PROLOG dialects along with compatibility libraries for several PROLOG implementations;

imposition of no arbitrary limits on programs and data;

an interface to C and C++;

a built-in message passing facility for distributed application development;

fully automatic memory management with garbage collection;

arithmetics with unlimited precision integer and rational numbers;

profiling tools to collect statistics and timings;

a collection of libraries for program development; and

an interface to Tcl/Tk.

Binary releases of ECLiPSe are freely available to universities and non-profit research institutions. Distributions are available for Linux and other platforms upon signing and faxing an academic license agreement. Extensive documentation is available.
[http://www.icparc.ic.ac.uk/eclipse/]
eclipse: A collection of UNIX image processing utilities developed for the reduction of astronomical data. It includes many standard low-level functionalities as well as high-level calibration and cleaning procedures. It was chiefly designed and intended for astronomical infra-red data although most of the algorithms are standard image processing algorithms and thus have much wider application. This was designed to process images in the FITS data format.
The utilities comprising eclipse include:

3color, combines three FITS images of equal size into a single 24 bit image in PPM format;

average, reduces a FITS cube over its third dimension using a choice of algorithms;

catcube, creates an output cube that is the sum on the z-axis of a given number of other cubes;

ccube, a calculator for performing operations between cubes, cubes and constants, and constants;

deadpix, generates bad pixel maps from images of the sky background in infrared;

detpeak, detects and localizes bright object centroids in an image;

dfits, displays FITS file header information;

dumppix, dumps pixels from a FITS file;

encircl, computes the encircled energy for every plane in a cube;

extract, to extract data froma cube via several modes;

fft, computes an FFT on an image;

filt, a cube filter in the image domain with a choice of several filters;

fitsedit, online FITS header management services;

fitsort, extracts keyword values from a set of FITS files;

flat, processes twilight data cubes to create linear gain and bad pixel maps;

fpclean, removes cosmic rays from a Fabry-Perot data cube;

fpflat, flat fields a Fabry-Perot data cube;

fwhm, computes the full width at half maximum around peaks in a FITS data cube;

growcube, builds a new cube using a 1-D spectra and an image;

imgen, creates an image with a given pattern definition and parameters;

ipaste, inserts one image into another image;

jitter, reduces images taken in infrared jitter imaging mode;

photfits, computes the flux in ADU inside a specified disk in an image;

poisson, generates random points on a 2-D plane with a Poisson law distribution;

shiftxy, shifts an image by a given offset;

spectract, extracts a 1-D spectra along the z or plane axis of a 3-D cube using an extraction map image;

strehl, computes the Strehl ratio for every plane in a cube;

thresh, threshold a cube/image to another cube/image or pixel map; and

warping, resamples images according to a given transformation, e.g. rotating, zooming, translating, etc.

A source code distribution of eclipse is available under the GPL. It is written in standard C and can be compiled on most UNIX platforms. A user's manual is available in HTML and PostScript formats.
[http://www.eso.org/eclipse/]
ECLIPT Mirror: A mirroring program for FTP and Web sites. The features include:

downloading files not older than N days and deleting local files older than N days;

a maximum for deleting files;

support for most FTP daemons;

parallel execution of mirrors via forking;

optional recursive downloads of directories;

generation of log files in HTML format;

downloading the newest version of a package; and

downloading and excluding using regular expressions.

A source code distribution of the Python script is available.
[http://eclipt.uni-klu.ac.at/projects/emirror/]
ecological simulation: Related packages include:

AME

Echo

EcoSim

SIMEX

Swarm

Tierra
Econometrics Toolbox: A set of Matlab functions that implement various econometric estimation methods. The 300+ programs in this toolbox are divided into several categories including:

utility functions including those for working with time series data, printing and plotting matrices, performing econometric data transformations, and mimicing various Gauss statistical function;

a regression diagnostics library including functions for diagnosing and correcting collinearity problems and for detecting and correcting for outliers and influential observations in regression problems;

a library of vector autoregression (VAR) and error correction (EC) models;

a Gibbs sampling function library implementing Markov chain Monte Carlo models;

a regression function library containing routines for estimating limited dependent variable logit, probit and tobit methods as well as Gibbs sampling functions for estimating these models;

a regression function library containing routines for two-stage least squares, three-stage least squares, and other regression models;

a distribution functions library for carrying out calculations based on a wide range of statistical distirbutions including the beta, binomial, chi-square, F, gamma, hypergeometric, log-normal, logistic, multivariate normal, Poisson, standard normal and Student t distributions; and

an optimization function library with routines for the maximum likelihood estimation of econometric models.

A source code distribution is available which is documented in two separate manuals in PostScript and PDF format weighing in at a combined 500+ pages.
[http://www.spatial-econometrics.com/]
eCos: The embedded Cygnus operating system is an open-source, configurable and portable real-time operating system (RTOS). It is designed to be portable to a wide range of target architectures by running the kernel and other runtime components on top of a Hardware Abstraction Layer (HAL). It has also been designed to support embedded applications with real-time requirements. The real-time kernel includes interrupt and exception handling, a choice of schedulers, thread support, a rich set of synchronization primitives, timers and counters, a choice of memory allocators, and debug and instrumentation support. An ISO C library is included in the distribution. Current (12/98) supported targets are the Matsushita MN10300 processor, Toshiba TX39 processor, and the PowerPC MPC860 processor. Supports hosts are Linux and Windows NT. A source code distribution is available.
[http://sourceware.cygnus.com/ecos/]
EcoSim: A C++ class library especially designed to support individual-oriented discrete event simulation and ecology. The process of implementing individual-oriented models is facilitated by providing classes for those parts common to all such models. Ecologists may concentrate on the unique parts of their models and leave the gory details to EcoSim. The EcoSim libraries provide support for: the specification of static and dynamic properties of individuals; the specification of dynamically changing environments wherein cells in the environment change similarly to the individuals contained therein; and support for the on-the-fly analysis and animation of data generated by the system. EcoSim is designed primarily for use with ecological models but may be used for any discrete-event, object-oriented model.
The source code for EcoSim is written in C++ and has been tested on Linux and UNIX (with gcc 2.6.3 or greater) and Windows NT/95 platforms. The source code has not yet been released while a complete documentation package is being written.
[http://offis.OFFIS.Uni-Oldenburg.DE/projekte/ecotools/project_ecotools4.htm]
ECS: The Element Construction Set is a Java API for generating elements for various markup languages. It directly supports HTML 4.0 and XML and can easily be extended to create tags for any such language. ECS allows Java Objects to be used to generate markup code rather than using a series of print statements to output verbatim markup. The features include:

an HtmlColor interface that defines over 200 colors by name rather than hex value;

automatic replacement of ampersands, quotes, double quotes, etc. by their entity counterparts (in a configurable manner); and

the capability of writing directly to an elements output stream to provide custom rendering of elements.

A source code distribution is freely available.
[http://java.apache.org/ecs/]
ed: A GNU line-oriented text editor which can be used to create, display, and modify text files interactively and from shell scripts. GNU ed originated with the editor algorithm in Kernighan and Plauger (1981) and is not an 8-bit clean, POSIX-compliant line editor. Also included is red, a restricted version of ed that can only edit files in the current directory and can't execute shell scripts.
A source code distribution of ed is available. It is written in C and can be compiled and installed on most UNIX platforms via an included configure file. It is documented in a user's guide available in Texinfo format as well as in a man page.
[http://www.gnu.org/software/ed/ed.html]
EDA: A collection of Fortran routines for Exploratory Data Analysis. These routines are from a book about exploratory data analysis (Velleman and Hoaglin (1981)). EDA emphasizes the discovery of the structure and anomalies in a set of data and also minimizing the number of assumptions made about the data (e.g. normality, additivity of effects, independence of observations, etc.). The routines available include stem-and-leaf displays, letter-value displays, boxplots, x-y plots, resistant line fitting, data smoothers, coded tables, median polish, and rootograms. See also Tukey (1977).
[ftp://ftp.ucar.edu/dsl/lib/eda/]
Eddi: A GUI text editor built using the Tix extensions to Tcl/Tk. The features of Eddi include: the colorization of several programming languages, a make interface with error and warning colorization and the capability of jumping from error to error, an RCS interface, unlimited undo/redo, multiple file editing and project handling, bookmarks, unlimited macros that can be saved between sessions, full keyboard control of all functions, all of the usual editing functions, and much more.
A source code distribution of Eddi is available. It can be installed on any UNIX flavor which already has Tcl/Tk and Tix installed.
[http://rpmfind.net/linux/RPM/eddi.html]
Eddie: An Open Source project and set of cluster applications for building highly robust and scalable server farms. The components of Eddie include:

an IP migration application for setting up overlapping take-over and fail-over sets using any type of servers;

a load-balancing DNS server that is plug-in compatible with BIND 4.*;

an intelligent HTTP gateway that is a peer which sits on top of back-end HTTPO servers such as Apache; and

a content replication application in the form of a fully replicated and distributed LAN/WAN file system designed primarily for robustness.

The components of Eddie are currently (11/98) available as pre-compiled software, although source code releases are planned when the code is considered sufficiently mature. Documentation is available for each component in PostScript and other formats. Eddie is built using Erlang.
[http://www.eddieware.org/]
EDGR: An EDitor for GRaphics which is an interactive program for creating, editing, printing, and storing graphical data. It was developed at TRIUMF to enable users to create line drawings, to store graphical output from other programs in a device independent format, to edit and combine drawings, and to produce suitable hardcopy output for presentation, publication, or archiving. EDGR can edit the graphics produced by programs that use the GPLOT graphics library (used internally by PHYSICA) as well as those produced in the HPGL, DM/PL, and Tektronix 4010/4014 formats. (Unfortunately it can't read PostScript files.) Hardcopy output can be produced for several devices including Printronix, HP (GL, Laserjet, and Thinkjet), DEC LA100 and LN03+, Imagen laser printers, HP Paintjet printers, and PostScript printers.

EDGR provides a basic set of drawing tools where elements such as lines, arcs and text can be entered, moved and modified. Groups of elements or whole drawings can be cut, pasted, scaled, rotated, translated, and included in other drawings. Attributes such as color, line type, or text font can be modified globally or on a per element basis. Other available functions include magnification, area filling, text justification and alignment, and spline smoothing. Various CAD-like features are also available including grid overlays, independent graphics layers, full precision coordinate storage, distance and angle measurement, and numerical coordinate input for any graphical operation. Graphics objects can be defined as modular components that can be dynamically entered into any drawing, and sequences of editing functions can be automated via the use of script files. Also included are features for combining multiple drawings for presentation or archiving.
Binary versions of EDGR are available for several platforms including Linux Intel. It is documented in an 80+ page user's and reference manual available in PostScript format.
[http://www.triumf.ca/compserv.html]
Edinburgh Speech Tools Library: A collection of C++ classes, functions and related programs for manipulating the types of objects used in speech processing. The functionality includes reading and writing waveforms as well as creating and manipulating parameter files in various formats and converting between them. There are also quite a few utility programs built using the library for performing various tasks. These programs include:

ch_wave, for manipulating the format of a waveform file, e.g. file format conversion, resampling, byte-swapping, scaling the amplitude of the waveform, etc.;

ch_track, for manipulating the format of a track file, e.g. file format conversion, smoothing, producing differentiated and delta tracks, etc.;

ch_lab, for manipulating the format of label files;

tilt_analysis, for producing a Tilt or RFC analysis of an F0 contour;

tilt_synthesis, for generating F0 contours from Tilt descriptions;

sig2fv, for generating signal processing coefficients from waveforms via various types of analysis, e.g. linear prediction (LPC), cepstrum coding from LPC coefficeints, line spectral frequencies, etc.;

spectgen, for creating spectrograms, i.e. 3-D plots of amplitude vs. time vs. frequency;

sigfilter, for performing various filter functions on waveforms;

design_filter, computes the coefficients of an FIR filter with a given frequency response;

pda, implements a pitch detection algorithm that produces a fundamental frequency contour from a speech waveform file;

pitchmark, locates glottal closures in a laryngograph waveform;

dp, uses dynamic programming to find the lowest cost alignment of two symbol sequences;

ngram_build, for building/training an n-gram language model;

ngram_test, for testing n-gram language models;

viterbi, a time-synchronous Viterbi decoder for combining an n-gram model and likelihoods to estimate posterior probabilities;

na_play, a general audio playback program;

na_record, for recording waveforms from an audio device;

wagon, for building CART trees from feature data;

ols, for training a linear regression model;

ols_test, for testing a linear regression model;

wfst_build, for building a weighted finite-state transducer;

wfst_run, for running a finite-state transducer;

scfg_make, makes the rules for a stochastic context-free grammar;

scfg_train, trains the parameters of a stochastic context-free grammar;

scfg_parse, parses text using a pre-trained stochastic context-free grammar;

scfg_test, applies a stochastic context-free grammar to a given corpus and reports the parsing and cross-bracketing accuracies;

siod, a command-line interface to a modified version of the SIOD Scheme interpreter;

bcat, a binary safe version of cat; and

xml_parser, a front-end to the RXP XML parser.

This library and the tools constructed with it are designed to make the construction of other speech systems easier. For example, it is used to provide the underlying classes in the Festival speech synthesis system. The full source code is freely available for unrestricted use, and a very complete manual is available.
[http://www.cstr.ed.ac.uk/projects/speech_tools/]
editors: Several text editors are available for the Linux platform. There are the classic Emacs and its spinoff XEmacs. There are also the many vi emulators. Those which are X Window-based include:

aXe,

ce,

cooledit,

gloe,

Jade,

jcc,

JED,

jEdit,

Lyx,

mars_e,

MEdit,

NEdit,

Point,

Sam,

Scriptum,

TED,

thot,

vi, the ancient and venerable UNIX editor;

Xcoral,

Xenon,

XHTML,

XRedit,

xwb, and

xwpe.
eEMU: The enterprise Event Management Utility is a package that manages, displays and takes action on messages sent by various monitoring agents, i.e. a message handling framework and consolidator. Unlike similar commercial packages, this is an Open Source package based on standard scripting tools and languages. The features and functionality of eEMU include:

event management via a flexible messaging core;

a distributed, multi-tier and highly scalable framework with building blocks that can easily combined almost without limit;

a portable message agent written using standard TCP/IP programming interfaces;

heuristic algorithms for handling messages and deciding when problems have been fixed;

central management by an eEMU manager program that exports all problems reported by agents into a database;

a console from which messages stored by the manager can be viewed and acted upon;

automation of problem detection and corrective actions, with programs for the latter supported when written in nearly any programming language;

easy and flexible logging and statistical reporting;

integration with enterprise management systems via messaging interfaces that can consolidate events and create reports in the proper format; and

provision of password-based security.

The various eEMU components (e.g. manager, browsers, agents) are separately available as source code. The documentation includes various tutorials and manuals in PDF format.
[http://www.jarrix.com.au/]
EFFTool: The Error, Fault and Failure Tool is is interactive WWW tool for collecting data consisting of general project information and specific information related to the discovery and resolution of faults and failures occurring during the development or maintenance process. There is also an analysis component providing the capability to sort and count faults having certain characteristics and to perform various calculations and comparisons on those faults. A source code distribution of this public domain tool is available. It is written in Perl.
[http://hissa.ncsl.nist.gov/project/eff.html]
EFLIB: An application framework implemented in Object Pascal with fundemental components for data structures, mathematics, graphics and text processing. EFLIF provides elegant object-oriented solutions that can be used by everyone from novice to expert programmers. It is a programming framework that provides a set of classic data structures implemented with high-performance algorithms, a number theoretic system with generic arithmetic, mathematical functions, text processing and converting, fast searching, parsing, abstract graphics classes, a meta-engine with support for a distributed object model, database support, image processing and more.
A source code distribution of EFLIB is available. It supports both FPKPascal and GNU Pascal after release 6. A user's guide and reference manual are available amongst quite a bit of documentation.
[http://www.csd.uu.se/projects/EFLIB/]
egcs: Note: This was merged with GCC in April 1999 with the first combined version being GCC 2.95. A project to integrate various variations to and patches for the GNU C compiler GCC. The features of egcs include:

most of the new features in GCC 2.8.*;

integration of the g77 0.5.22 compiler;

vast improvements in the C++ compiler;

integrated C++ runtime libraries;

a new instruction scheduler which includes support for function wide instruction scheduling and superscalar scheduling;

improved alias analysis code;

improved register allocation for two address machines;

significant code generation improvements for Fortran code on Alphas;

integration of various optimizations from the g77 project;

support for Dwarf2 debug format;

inclusion of the SGI STL into libstdc++; and

integrated testsuites for gcc, g++, g77, libstdc++ and libio.

Snapshots are available onsite as well as mailing lists for those interested in development.
[http://www.cygnus.com/egcs/]
Eggdrop: An IRC robot which features a flexible configuration file and a built-in Tcl script parser. A source code distribution of this C package is available.
[http://www.eggdrop.net/]
[http://www.eggxpress.com/downloads/downegg.html]
[http://www.roon.org/eggdrop/]
EGO: A program for performing molecular dynamics calculations on parallel and sequential computers. EGO has been used to compute trajectories for molecular systems containing more than 35,000 atoms with extended atoms or with explicit hydrogen atoms. Input files consist of PDB files for the atomic coordinates and X-PLOR compatible PSF and parameter files for topology information and force constants.
Molecular dynamics calculations as performed by EGO involve numerically integrating the equations of motion of atoms in molecules. Electrostatic and van der Waals interactions represent non-bonded forces between atoms with bonded interactions represented by stretching, torsion, and stearic hindrance potentials. The computation of the short range forces increases linearly with the number of atoms, but the longer range Coulomb interactions increased with the square of this number. EGO uses a method which combines a fast multipole method (FMM) and a multiple timestep method to reduce the required computational effort for evaluating the Coulomb interactions. The combination of algorithms is called a fast multipole timestep structure adapted multipole method (FAMUSAMM).
A source code version of EGO is available. It is written in C and can be used with either PVM or MPI on any platform that supports them. A user's manual is available in either HTML or PostScript format.
[http://www.imo.physik.uni-muenchen.de/imo/gruppen/molgroup/moloverview.html]
Egon Animator: An X Window-based animation development tool for UNIX platforms. Animations can be written using the underlying Scheme implementation or by using the GUI interface. See also the same author's SIAG and Pathetic Writer.
[http://www.edu.stockholm.se/egon/]
EGP: The External Gateway Protocol is a routing protocol used on the DDN which enables networks to exchange information about how to reach other networks. This is used on nodes that are external gateways as opposed to the use of RIP on internal gateways.
[http://www.faqs.org/rfcs/rfc904.html]
[http://www.faqs.org/rfcs/rfc1092.html]
Egret: An advanced framework for the construction of computer-supported cooperative work applications. Egret provides both low and high level storage and communication facilities for the development of cooperative work applications. The features include:

data representations can range from unstructured binary storage to schema-based, typed, structured storgae records to HTML-compatible hypertext;

indexing and local replication mechanisms enable efficient relational-style queries over the underlying network database;

interprocess communication is implemented via TCP/IP sockets and provides a variety of programmatic and interactive client communication facilities;

password mechanisms are provided to facilitate secure collaboration in dispersed groups;

built-in instrumentation support to facilitate research and evaluation of Egret applications;

several example CSCW application implementations.

The example applications included in the Egret package include:

CSRS, a collaborative software review system implementing a process modeling language for the definition and enactment of software quality improvement methods;

AEN, a collaborative hypertext authoring environment providing extensive group process visibility called strong collaboration;

Shemacs, a drop-in extension to Emacs providing a shared, real-tiem concurrent Emacs editor with character-level locking; and

Flashmail, a real-time message facility providing a complementary communication channel to email.

Source and binary distributions of the Egret system are available, with the latter including one for Linux Intel platforms. Documentation includes a primer and a design reference manual, both of which are available in both HTML and TeX format.
[http://csdl.ics.hawaii.edu/Tools/Egret/Egret.html]
EiC: Extensible interactive C is a hand-crafted, recursive-descent C intepreter developed from a perceived need for a complete interactive C interpreter or, more correctly, an interactive bytecode C compiler which can also be used non-interactively in the usual compiler batch mode manner. The latter allows EiC to compile and run C programs without leaving executables or object files around to clutter up the area. It is one of the most complete C interpreters yet built and is designed to be a production tool which can be used as an aid in teaching C as well as for quickly prototyping new research programs.

EiC is a bytcode compiler that generates its own internal intermediate language (known as stack code) which it executes via an internal stack machine. It differs from C in that it is pointer safe (i.e. it detects many classes of memory read and write violations), goto statements and labels are not supported, long jumps are not supported, structure bit fields are not supported, it is illegal to pass a structure or a union to a variadic function, the C concept of linkage is not supported, preprocessor numbers which aren't valid numeric constants aren't parsed, C and C++ type comments are supported, there are no default type specifiers for function return values, trigraph sequences aren't supported, there is no #line directive in the preprocessor, and more.
A source code distribution of EiC is available which is currently (3/98) supported on Linux Intel, Sun Solaris and SunOS, DEC Alpha OSF, and SGI IRIX platforms. An extensive manual is available in both HTML and PostScript formats. EiC is freely available only for non-commercial usage.
[http://www.anarchos.com/eic/]
Eiffel: An object oriented language of some complexity. Non-commercial compilers/interpreters include Eiffel/S, eon, and SmallEiffel. Eiffel texts include Meyer (1991), Switzer (1993), and Thomas and Weedon (1995).
Eiffel/S: An Eiffel compiler for Linux.
[http://sunsite.unc.edu/pub/Linux/devel/lang/eiffel/]
eigenvalues: Software packages for finding eigenvalues include:

ARPACK

ARPACK++

CPQR79

EIGENTRI

EISPACK

GNUSSL

HQR3/EXCHNG

HSL

LANCZOS

LANZ

LAPACK

LAPACK++

LASO

LASSPTools

LICEPAK

LZHES

MATCALC

Meschach

MEVAS, for solving the eigenvalue assignment problem for multi-input systems using state feedback;

MTIEU, for calculating eigenvalues of Mathieu DEs for noninteger and integer order;

NAPACK

Newmat

Octave

Ox

PeIGS

PORT

QMRPACK

QR2NOZ

QZ

RLaB

ScaLAPACK

Scilab

SCPACK

SEVAS, for solving the single-input eigenvalue allocation problem;

SICEDR

SIMITZ

SLEIGN2

SL11F/SL12F

SYISDA

Tela

TRLan

Viewit
EIGENTRI: A set of Fortran programs for reducing a nonsymmetric matrix to tridiagonal form, computing the eigenvalues of the tridiagonal matrix, improving the accuracy of an eigenvalue, and computing the corresponding eigenvector. The intended purpose is to find a few eigenpairs of a dense nonsymmetric matrix faster and more accurately than previous methods. This is TOMS algorithm 710 and is documented in Dongarra et al. (1992).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
8Hz-MP3: A package for writing to, i.e. encoding, MPEG-3 files. As of 12/98 this is unavailable due to legal problems.
[http://www.8hz.com/mp3/]
EISPACK: A collection of Fortran subroutines which compute the eigenvalues and eigenvectors of nine classes of matrices, i.e. complex general, complex Hermitian, real general, real symmetric, real symmetric banded, real symmetric tridiagonal, special real tridiagonal, generalized real, and generalized real symmetric matrices. There are also two routines that use SVD to solve some least-squares problems. EISPACK has been mostly superseded by LAPACK and the latter should be preferred for most if not all uses. The source code and sparse documentation are available. This is part of CMLIB.
[http://www.netlib.org/eispack/index.html]
elastiC: A portable, high-level, object-oriented interpreted language with a C-like syntax. The features includle:

portable bytecode compilation;

dynamic typing;

automatic and very fast garbage collection;

object-oriented with meta-programming support;

functional programming features, e.g. Scheme-like closures with lexical scoping;

hierarchical namespaces;

several basic types, e.g. dynamic arrays, dictionaries, symbols, etc.; and

extensible with and embeddable in C.

[http://www.elasticworld.org/]
Electric: A sophisticated electrical CAD system that can handle several forms of circuit design including custom IC layout, schematic drawing, hardware description language specifications, and electro-mechanical hybrid layout. The CAD operations available in Electric include:

design rule checking;

simulation and a simulation interface;

PLA generation;

compaction and compensation;

routing;

VHDL and silicon compilation; and

network consistency checking.

Design types handled include MOS (6 CMOS variations and 1 NMOS variation), bipolar and BiCMOS, schematics and printed circuits, digital filters with temporal logic, and artwork. The file formats handled include CIF, GDS, VHDL and DXF for I/O and PostScript, HPGL and QuickDraw for output. A source code distribution is available.
[http://www.gnu.org/software/electric/electric.html]
[http://www.electriceditor.com/]
electromagnetic software: Available packages that deal with electromagnetics include:

DDSCAT, for calculating scattering and absorption of electromagnetic waves by targets with arbitrary geometries;

DISORT, for computing quantities related to radiative transfer in a multi-layer plane-parallel medium;

Emu/fdtd, which uses the FDTD method to solve Maxwell's equations in the time domain;

MIEPACK, a collection of programs for performing various tasks in electromagnetic scattering theory;

MIEV, for calculating quantities involved in electromagneitc scattering from a homogeneous sphere;

NEC, for analyzing the response of an arbitrary structure consisting of wires and surfaces;

ToyFDTD, a C program for solving 3-D problems in electromagnetics;

xspace, an educational package for introducing students to concepts of space physics including electromagnetics; and

Xwake, an FDTD code written for wake field and impedance calculations of rotationally symmetric structures;
Electronic Notebook Project: A project to develop an electronic notebook with which scientists and engineers can do remote experimentation and collaboration. Although this is being developed as a medium in which researchers can remotely record aspects of experiments conducted at research facilities, it can also be used as a private notebook for personal information and ideas or a single notebook project shared by a group of collaborators. The Notebook is a Web-based package in which each entry becomes a separate HTML page in which text and/or graphics are displayed. Reading from a Notebook requires only a browser, but adding entries requires one that is Java-compliant. Notebook data is automatically handled by Perl 5 scripts running at the site where the data is stored. Interactive input is accomplished via a combination of Java applets and CGI scripts. The available functions are divided in modifying and navigation function classes.
The features of the Notebook include:

modifying functions including add, edit, delete, annotate and notarize;

navigation functions including first, previous, next, last, contents and search;

an external navigation and control panel which allows easy access even on long pages;

drawing sketches via a Java applet sketchpad;

easy uploading of images from anywhere on the Internet;

an overview of Notebook features on the first page;

an on-line help Notebook linked from the first page; and

complete configuration of who can access what.

A source code distribution of the Notebook system is available via an email request. Quite a bit of documentation is available at the site.
[http://www.epm.ornl.gov/~geist/java/applets/enote/]
electronics: Software related to electronics or electrical engineering includes:

ACS, a general purpose electrical circuit simulator for nonlinear CD and transient analyses;

Alliance, a set of CAD tools and portable libraries for VLSI design;

brusey20, a tool for converting state diagrams into synthesizable VHDL;

Chipmunk, a collection of tools for electronic circuit simulation and schematic capture;

CynLib, a electronic hardware description library (HDL) written in C++;

Electric, an electrical CAD system for many forms of circuit design;

EOS

EXOR, an object-oriented digital circuit simulator;

FreeHDL, a project to develop an Open Source VHDL simulator for Linux

gEDA

GNUPIC, a suite of microcontroller development tools;

HADLOP, a tool and HDL for the design and simulation of digital 3-D optoelectronic computing systems;

Icarus Verilog, a Verilog simulation and sythesis tool;

Magic

MISTIC

ng-spice, a project to improve the capabilities of the Spice Version 3f5 simulator;

OCEAN

Pcb, an interactive printed circuit board design system;

POLIS, a package for hardware/software co-design of embedded systems;

SCEPTRE

SIS

SystemC, a modeling platform for System-on-Chip (SoC) design;

VAUL, a VHDL analyzer and utility library;

VHDL-GUI, a graphical tool for producing structural VHDL code from hierarchical block diagrams;

VPR, a CAD tool for the placement and routing of array-based FPGAs;

XCircuit, a program for drawing electrical circuit schematic diagrams and related figures.
Elegant: The Exploiting Lazy Evaluation for the Grammar Attributes of Non-Terminals is a programming language that started out as a compiler generator based on attributed grammars. Although inspired by the abstraction mechanisms found in modern functional languages, it is an imperative language. The features include:

a type system with strong typing, subtyping, polymorphic types and functions, lazy types, list comprehensions, overloading, automatic and user-definable coercions, and pattern matching;

attribute grammars that support LL(1) and LALR(1) parsing as part of the language and have integrated automatic error recovery;

user definable and overloadable operators;

function (i.e. lambda) expressions;

a module system;

many compile time and run-type checks;

compilation into ANSI C; and

self-generating, i.e. written in Elegant.

The components of the package include:

Elegant, a compiler for the Elegant language;

ScanGen, a lexical scanner generator;

Bnf, a BNF to attribute grammar conversion utility;

Diagrams, a BNF syntax diagram generator;

elegantmake, an Elegant makefile generator; and

cmake, a C makefile generator.

Distributions of Elegant are available for several platforms under the GPL. Documentation includes a language definition and an extended tutorial.
[http://www.research.philips.com/generalinfo/ special/elegant/elegant.html]
Elex: A multi-language scanner generator package which generates a scanner (i.e. a lexer) from a specification oriented around regular expressions. A scanner is a program that finds compound symbols in a stream of characters. Elex differs from most other scanner generators in that it supports multiple languages.
The Elex package consists of:

elex, a configurable front end for the Flex tool set which integrates the compiler, debugger, and any number of code generators;

elexc, the Elex compiler;

elexd, a debugger which allows the regular expressions in Elex scripts to be tested before being used in a scanner;

a code generator which generates a C++ scanner; and

a Graphviz code generator which generates files that can be used with Graphviz to visualize the FSM that Elex generates for a scanner.

Code generators for Java and Ada 95 are in the works.
A source code distribution of Elex is available as is a binary for Linux Intel platforms. Compilation requires g++ 2.7.2 and Perl 5. A user's guide is available in most popular UNIX formats.
[http://www.ozemail.com.au/~mpp/elex/elex.html]
ELF: This is a link to a site with information about ELF (Execution and Linking Format), the new binary format for Linux programs that will, amongst other things, make it much easier to build shared libraries.
[http://ftp.linux.org.uk/~barlow/linux/ELF-HOWTO.html]
ELFkickers: A collection of programs for working with the ELF binary file format. This includes:

sstrip, removes extra bytes from a binary file that strip leaves behind;

elfls, displays an ELF file's program and/or section header tables;

elftoc, generates C code that defines a structure with the same memory image as an ELF file (using the structures and preprocessor symbols defined in elf.h; and

ebfc, a compiler that can generate ELF executables, object files, and shared libraries.

Also included in the package is a small collection of ELF executables e.g., a version of cat written in assembly.
[http://www.muppetlabs.com/~breadbox/software/elfkickers.html]
ELI: A domain-specific programming environment consisting of a variety of standard tools which implement powerful compiler construction strategies. Eli can be used to automatically generate complete language implementations from application-oriented specifications. The implementations can be interpretive, using the constructs of the source language to invoke operations of an existing system, or involve translation into an arbitrary target language. Eli offers complete solutions for commonly encountered language implementation subtasks as well as libraries of reusable specifications.
Eli has been used to create:

programming language compilers for ANSI C to SPARC machine code, Pascal to Pcode, Pascal to C, and several user-defined languages;

special processors that translate musical notation to PostScript and statistical data to TeX tables or histograms;

program generators that produce C simulation programs from descriptions of mechanical systems, query language calls from a database description, and finite-element models from descriptions of solids;

interpreters that create animations from descriptions of graphics and interactively evaluation decision tables; and

analyzers that enforce programming style, interactively validate commands for satellite control, and compute and present statistics.

The various tools that comprise Eli include:

LIDO, a language for the specification of computations in trees used to specify all computations of the analysis and translation phase of a language processor;

LIGA, a system to process LIDO specifications and generate evaluator C modules from them by automatically determining a tree walk strategy and the evaluation order of computations on the basis of the specified dependencies;

GORTO, a graphical order tool for the analysis and modification of dependencies in attribute grammars within the LIGA system;

FunnelWeb, a literate programming system;

PTG, a pattern-based text generator which supports translations into any kind of structured text;

SHOW, which displays the internal representation of a

LIDO grammar;

OIL, an operator identification language which is a language and set of library functions used in the specification and implementation of operator identification within a compiler; and

COLA and PGS, two different parser generators.

A source code distribution of Eli is available. It is written in C and has been compiled and used on a wide variety of UNIX flavors including Linux Intel. There is a huge amount of documentation available for Eli in PostScript format. There are separate manuals for every component of the package as well as technical reports describing the overall package and various applications.
[http://www.cs.colorado.edu/~eliuser]
Elib: The GNU Emacs Lisp library is designed to be for Elisp programs what libg++ is for C++ programs, i.e. a collection of useful routines for performing various common tasks. Elib contains code for container data structures (e.g. queues, stacks, AVL trees, etc.), string handling and minibuffer handling functions missing in standard Emacs, and routines for handling lists of cookies in a buffer. It is designed to be as efficient and easy to use as possible.
A source code distribution of Elib is available. It is written in Elisp and can be used in the standard Emacs enviroment. It is documented in a 30 page user's manual available in Texinfo format.
[http://www.gnu.org/software/elib/elib.html]
Elk: The Extension Language Kit is an implementation of the Scheme programming language designed specifically as an embeddable, resuable extension language subsystem for applications written in C or C++. Applications with different components in different langauges can be developed using Elk, e.g. an efficient core written in C or C++ and an extensible user interface layer implemented in Scheme. It is also useful as a stand-alone Scheme implementation, in particular as a platform for rapid prototyping of X11-based Scheme programs.
The features of Elk include:

full incremental and dynamic loading which enables Scheme code to load compiled extensions into the running interpreter (or application) on demand and allows large, complex applications to be decomposed into dynamically loadable components as well as the inclusion of extensions written in other languages;

a new Scheme primitive called dump which freezes the dynamic runtime image of the interpreter into an executable file, with the executable resuming execution by returning from the call to dump that created it;

the tight integration of C/C++ applications via the extension language;

the definition of new Scheme primitives by applications;

the definition of application-specific first-class Scheme types;

converting objects between Scheme and C/C++ types;

the implementation of weak data structures;

defining Scheme variables and symbols;

evaluating S-expressions encoded as C strings; and

garbage collection.

. There are full Scheme bindings for Xlib, Xt, Xaw, and Motif as well as access to most UNIX systems calls and common C library functions. Two garbage collection strategies are selectable at compile time. Non-standard Scheme features include first-class enviroments, error handling, provide/require and autoloading, fluid bindings and dynamic-wind, simple ``eval-twice'' style macros, property lists, string and bidirectional ports, a debugger, and more.
A source code distribution of Elk is available. It is written in portable C and can be compiled with either a K&R or ANSI C compiler. Over 230 pages of documentation are available in both HTML and PostScript formats. Packages which are written in or use Elk include AL, unroff, GINGER, and Sced.
[http://www.informatik.uni-bremen.de/~net/elk/]
ELKS: The Embeddable Linux Kernel Subset is a project to create a version of Linux for 8086 to 80286 PCs, palmtop computers, single board microcomputers, embedded controller systems and other old computers. It is a small kernel subset that can run on small machines with limited processor and memory resources. It is currently (6/99) able to boot, provide virtual consoles, mount a root minix filesystems floppy, provide basic serial and parallel I/O, and start various small programs. Planned further functionality includes swapping, shared libraries and networking. Source code distributions are available.
[http://www.elks.ecs.soton.ac.uk/cgi-bin/ELKS]
ELLPTI: A Fortran 77 algorithm for computing a class of hyperelliptic integrals and for determining the surface measure of ellipsoids. This is TOMS algorithm 736 and is documented in Dunkl and Ramirez (1994b) and Dunkl and Ramirez (1994a).
[http://www.acm.org/calgo/contents/]
Elm: A mail user agent (MUA) designed to run with any UNIX mail transport agent (MTA). It is a replacement for and has a better user interface than programs like mail and mailx. Unlike earlier programs, Elm is screen-oriented rather than line-oriented, making it easier to use.
The source code for Elm is available in quite a few places as are binary versions for various platforms. Documentation is available as man pages or as a series of user's manuals in PostScript format, although one of the design criteria was to create a system that required little or no documentation for the casual user.
[http://www.myxa.com/elm.html]
ELROS: The Embedded Language for Remote Operations Service is a preprocessor which accepts language statements embedded in C programs and produces C code to encode/decode ASN.1 as well as send and receive remote operations. ELROS supports the distribution of scientific applications across multiple computing platforms by providing an embedded C language system for remote operations. Its goal is to provide portable, simplified access to efficient communications services. ELROS consists of the preprocessor and a library, with the library containing routines to encode/decode all primitive data types, to establish communication between processes, and to transmit and receive arguments of remote operations. It supports both socket and ISODE communication platforms, with the intermediate representation used for communication being the Basic Encoding Rules (BER) for ASN.1. This makes it interoperable with other presentation-level services which support ASN.1.
The source code for ELROS is available. The preprocessor is written in C++ and the library in C, with both compilable using gcc. The compilation process is not set up for Linux platforms, but it can be compiled rather easily by modifying the files used for compilation on ULTRIX platforms, taking care to indicate where the g++ include files can be found. The package is extensively documented in several manuals and technical reports, all available in PostScript format within the distribution.
[http://www.llnl.gov/sccd/lc/DEG/elros.html]
elvis: The editor like vi is the GNU clone of vi.
[http://www.fh-wedel.de/elvis/]
[http://heather.cs.ucdavis.edu/~matloff/elvis.html]
EMA-XPS: A hybrid graphic expert system shell that combines artificial intelligence (AI) features such as object-oriented data representation, forward and backward chained rules, prolog clauses, and constraint networks with a graphical interface based on X11 and the OSF/Motif widget library (although the author wants to switch to Lesstif as soon as possible). It is presently available as source code and in binary (a.out) form.
[http://www.iai.uni-wuppertal.de/EMA-XPS/]
Emacs: The editor that's everything to some folks and nothing to others. Emacs is a stateless editor, i.e. there aren't separate modes (as, for instance, in vi) for text browsing and entry. Various combinations of the non-character keyboard keys are used to enter literally hundreds (if not thousands) of commands, leading some to posit that Emacs is an acronym for "Escape Meta Alt Control Shift". Emacs is written in a language called ELISP (Emacs LISP), and thus its extensibility is limited only by your imagination and your command of ELISP. This also means that there are quite a few add-on packages for Emacs that let you read Usenet news and do almost anything from within the editor. The given link is to a searchable hypertext version of the Emacs FAQ, which should tell you everything you might want to know about it as well as how to get it and all its extensions. A version of Emacs which is enhanced for multilingual applications is available via the MULE project. See Abrahams and Larson (1996), Cameron et al. (1996), and Glickstein (1997).
[http://www.emacs.org/]
[http://www.eecs.nwu.edu/emacs/faq/]
[http://www.anc.ed.ac.uk/~stephen/emacs/ell.html]

AUC TeX

An extensible package that supports writing and formatting TeX files for most variants of the GNU Emacs editor. This supports many different macro packages including AMS TeX, LaTeX, and Texinfo.
The distribution includes the source code, written in Emacs Lisp (i.e. Elisp) and a 60+ page manual in Texinfo format. Some useful ancillary packages are available for AUC TeX, including x-symbol, CDTeX, a LaTeX mode that can run on top of AUC TeX; RefTeX, a mode that provides support for doing labels, references, and citations in LaTeX on top of AUC TeX; and many more.
[http://sunsite.auc.dk/auctex/]
[http://tug2.cs.umb.edu/ctan/tex-archive/support/auctex/]

BBDB

The Big Brother DataBase is a Rolodex-like database program for Emacs that is tightly integrated with the mail and news readers.
[http://www.jwz.org/bbdb/]

JDE

The Java Development Environment is an Emacs Lisp package that interfaces Emacs to command-line Java development tools. The features include:

a JDE menu with compile, run, debug, build, browse, project and help commands;

source code editing with syntax highlighting and autoindentation;

automatic generation of class and method skeletons;

running Java applications in an interactive Emacs buffer;

integrated debugging with an interactive debug command buffer and automatic display of current source file/line when stepping through code;

browsing JDK documentation;

browsing source code using Emacs etags or a tree-structured speedbar;

complete customizability; and

support for the latest JDK version.

A JDK installation is required to use this. A user's manual is available in the obvious formats.
[http://sunsite.auc.dk/jde/]

RefTeX

A minor mode for Emacs which provides support for doing labels, references, and citations in LaTeX. It will interface with AUCTeX.
[http://www.strw.leidenuniv.nl/~dominik/Tools/]
email: Electronic mail refers to sending messages analogous to snail mail (i.e. the stuff your postman picks up and delivers) via the Internet. See mail user agents, mail transport agents, and mailing lists.
[http://www.faqs.org/faqs/mail/setup/unix/part1/]
EMAP: The ElectroMagnetic Analysis Program is a family of 3-D finite element modeling codes that can be used to analyze bounded, 3-D geometries. They are not intended to compete with commercial codes but offer ease of use, modest resource requirements, and accurate modeling of simple 3-D configurations over a wide range of frequencies. EMAP1 uses a variational formalation, EMAP2 uses a Galerkin finite element formulation, and EMAP3 is a vector (edge element) code.
The source codes, written in C, are available along with binaries for Sun, IBM and HP platforms. The documentation is contained within journal and conference papers referenced at the web site. See Hubing et al. (1993).
[http://www.emclab.umr.edu/emap.html]
[ftp://emclab.ee.umr.edu/pub/emap/]
embeddable languages: Software related to embeddable languages includes:

ATLAST

BOIL

ECL

eCos

Elk

ELKS

ELROS

Fiasco

Forth

FPL

Guile

HyTech

ICI

Jacl

Lua

mktclapp

mod-perl

MzScheme

OScheme

POLIS

PTUI

Slang

Tcl
embedded Linux: There are several projects that have ported versions of Linux to embedded systems, i.e. small or limited systems usually designed for the real-time control of applications. Such projects include:

RTLinux, with a kernel enhanced to support hard real-time control programs;

uClinux, a port of Linux 2.0 to systems without a Memory Management Unit (MMU)

[http://www.embedlinux.net/]
EMBOSS: The European Molecular Biology Open Software Suite is a collaboration which aims to integrate a range of currently available packages and tools for sequence analysis into a generally available suite of programs and libraries. The goals including building a new set of core libraries in ANSI C, developing new applications, and integrating with other publicly available packages. Specific targeted applications in sequence analysis and related areas include those for:

EST clustering;

rapid database searching with sequence patterns and for sequence overlaps;

simple and species-specific repeat identification;

nucleotide sequence pattern analysis;

codon usage analysis for small genomes;

gene identification tools for genomic sequencing;

rapid identification of sequence patterns in large-scale sequence sets;

protein motif identification including domain analysis; and

presentation tools for publication.

The currently available EMBOSS applications include:

antigenic, to predict antigenic regions of a protein;

chaos, for creating a chaos plot for a sequence;

compseq, counts the composition of dimer/trimer/etc. words in a sequence;

cutseq, removes a specified section from a sequence;

descseq, alter the name or description of a sequence;

dotplot, create a DNA sequence dot plot;

emma, a multiple alignment program;

etandem, looks for tandem repeats in a nucleotide sequence;

fuzznuc, for nucleic acid pattern searching;

helixturnhelix, finds nucleic acid binding domains;

maskseq, masks regions of a sequence;

palindrome, looks for inverted repeats in a nucleotide sequence;

pepinfo, plots simple amino acid properties in parallel;

pepwheel, for creating a protein helical wheel plot;

pepwindowall, calculates general amino acid properties for sequence alignments;

prettyplot, displays aligned sequences with coloring and boxing;

pscan, locates fingerprints in a protein sequence;

restrict, finds restriction enzyme cleavage sites;

seqmatchall, performs sequence comparison;

sigcleave, predicts signal peptide cleavage sites;

stretcher, globally aligns two sequences;

tfscan, scans DNA sequences for transcription factors; and

transeq, translates nucleic acid sequences.

Many, many more programs are available, under construction, or proposed.
A source code distribution of the EMBOSS package is available. It is written entirely in ANSI C, although future extensions to C++ are mentioned. A fair amount of documentation is available including guides to using and developing the software, library and documentation standards, and man pages for each program.
[http://www.sanger.ac.uk/Software/EMBOSS/]
Embperl: A Perl module which allows you to embed Perl code in HTML documents. Embperl escapes the output of the embedded Perl code so HTML conformity isn't necessary and anything that's allowed in a normal Perl program can be used.
[http://perl.apache.org/embperl/]
EMC: A package which implements real-time control of equipment such as machine tools, robots and coordinate measuring machines. The four components of the EMC package are:

EMCCOT, a motion controller that includes sampling the position of axes to be controlled, computing the next point on the trajectory, interpolating between the trajectory points, computing an output to the motors based on a PID compensation algorithm, and writing to the motors;

EMCIO, a discrete I/O task controller with an API;

EMCTASK, a task executor; and

external programs such as a GUI which are used to run the EMC.

This is built on top of and heavily uses the RCS library. A source code distribution is available which has been successfully compiled and used on Linux platforms on which the Real-Time Linux extensions have been installed.
[http://www.mel.nist.gov/projs/isd/emc.html]
[http://www.nist.gov/public_affairs/guide/meltxt03.htm]
EMC2: A WYSIWIG 2-D finite element mesh generator. This package allows you to create and modify the geometry, define the discretization on the lines, define the subdomains, and define reference numbers for the boundary conditionss and material properties. Triangle and rectangle elements are available. Two kinds of meshes are available: grid meshes and Delaunay Voronoi automatically generated meshes.
The source code for EMC2 is available and can be compiled with ANSI C compilers. It has been tested on HP 9000, SGI, AIX, Linux, FreeBSD, and MacOS platforms. The documentation is contained within a technical report available in the same directory as the source code. This software was created as part of the GAMMA Project at INRIA.
[http://www-rocq.inria.fr/gamma/cdrom/www/emc2/eng.htm]
[ftp://ftp.inria.fr/INRIA/Projects/Gamma/]
[http://www-rocq.inria.fr/gamma/cdrom/projs/gamma/]
EM86: A Linux/x86 emulator for Linux/Alpha which uses components of Digital's FX32 technology to enable Linux/Alpha systems to run Linux/x86 software without modification. It currently (4/97) supports statically and dynamically linked x86 ELF32 binaries under Linux/Alpha, with planned enhancements including support for iBCS-2 compliant executables, improved emulator performance, and interoperation with natiave Alpha code.
[ftp://ftp.digital.com/pub/DEC/Linux-Alpha/em86]
Emerald: A programming language designed and developed to demonstrate that the object-based style of programming can be incorporated both elegantly and efficiently in a distributed programming enviroment. The primary goal of Emerald is to simplify distributed programming via language support while providing acceptable performance and flexibility both in local and distributed environments. It presents a unified semantic view of objects (similar to that seen in Smalltalk) appropriate for private, local, data-only objects as well as shared, remote, concurrently-executing objects. Other features include:

no notion of class;

support for data abstraction, i.e. all typing of objects is done at an abstract level and doesn't depend on the implementation chosen;

type consistency and conformity;

inherent polymorphism; and

extension of exception handling mechanisms to recovering from partial failures of distributed systems.

Binary versions of Emerald are available for several platforms including Linux Intel. Documentation includes a language report and a primer, both available in PostScript format.
[http://www.cs.ubc.ca/nest/dsg/emerald.html]
Emerge: An effort to build a new search infrastructure that addresses issues of scale and heterogeneity via the use of a distributed architecture. The goal is to work with data providers and those who build search clients to deploy search standards across a variety of scientific data repositories and to scale those and other search techniques by building polyglot gateways that can farm out queries to large collections of remote data sources. The projects and software presently (8/98) comprising Emerge include:

Gazebo, a search gateway that can execute a single abstractly specified query against multiple target data sources (e.g. Z39.50 servers) simultaneously, performing any necessary protocol translations and field mapping and managing network connections to the target data sources;

Gazebo Client Toolkit, a Java toolkit that performs all of the parsing of the XML-based protocol used for communication among clients; and

Pizazzd, a server toolkit library written in C that handles the Z39.50 protocol on the server side.

Source code distributions of each of these components are available.
[http://emerge.ncsa.uiuc.edu/]
emil: A tool for converting between message formats used by MIME, Eudora, SUN mailtool, PC and Mac based clients, etc. It is easily extensible. It can work either standalone, as an argument driven filter program, or, if linked with sendmail-5.67b+IDA-1.5 or sendmail-8.6.8, as a mail gateway convertering messages sent between various types of Internet mail clients. It will give a possibility to convert encoding formats of attachments and convert character sets of text. It can make a heterogenous mail environment, consisting of various types of mail clients, act as a homogenous environment; for instance sending only MIME based messages to the outside world.
The source code, written in C, is included with the distribution. A tutorial is available either online in HTML format or in PostScript form in the distribution.
[ftp://ftp.uu.se/pub/unix/networking/mail/emil/]
EMLIB: A library of electromagnetic software and related information.
[http://emlib.jpl.nasa.gov/]
EML Kit: A basis and test-bed for a comfortable framework for the formal development of programs using the Extended ML language, formalism, and methodology. This is a complete implementation of the Extended ML programming language, allowing for parsing, type-checking, and evaluation of arbitrary EML code, be it pure Standard ML or EML with its axioms and other useful specification constructs.
The EML Kit 1.0 (3/97) release is available in source code or as a binary for either Sun SPARC or Linux/Intel platforms. The documentation is contained within a user's guide available in PostScript format.
[http://zls.mimuw.edu.pl/~mikon/ftp/EMLKit/README.html]
EMMIX: A Fortran 77 program for the fitting of normal or t-component mixture models to multivariate data using maximum likelihood via the EM algorithm. In this approach an initial estimate is made of the vector of unknown parameters or, equivalently, an initial classification of the data with respect to the components of the mixture model under fit. EMMIX automatically performs this fitting and, if needed, provides a suitable set of initial values. A source code distribution is available. See McLachlan and Basford (1988) and McLachlan and Krishnan (1997).
[http://www.maths.uq.edu.au/~gjm/emmix/emmix.html]
Emonitor: A notification, action-based system for monitoring networks, systems and applications. This consists of several tools including:

emsrvmsg, a server message program that runs in a monitoring machine and collects messages from agents;

emsrvcmd, a server command program that runs on a monitored machine and listens for commands to be performed;

emtlog, a transaction logger that synchronizes the spool file and deletes specified messages;

emconsole, a console with which messages can be acknowledged and sorted, emails sent and checked, etc.;

emputcmd, a put command program used for sending actions to a specified client machine; and

emputmsg, a put message program that allows any script to send server messages.

The features of Emonitor include:

an unlimited number of agents;

proactive management, i.e. actions and tasks performed automatically;

cluster support;

support for heterogeneous networks;

multiple console monitors running simultaneously;

message history;

multiple acknowledgement of messages and levels of warning;

low load rate on monitored and console machines;

configuration via files or shell variables;

use of TCP/IP for messaging;

buffering security to prevent network failures;

user profiles; and

user access security.

The available monitors include:

emdskagt, a disk agent supporting file configuration, warning levels, autoconfiguration, etc.;

emprcagt, a process agent supporting keep alive, CPU time level, I/O level, orphan detection, etc.;

emkrnagt, a kernel agent that filters and processes all kernel logs;

emsrvagt, a service agent that checks specified network services; and

emnetagt, a network agent that ensures network connectivity.

A source code distribution is available under the GPL. This requires Tcl/Tk 8.0 or greater and Tix.
[http://www.gsyc.inf.uc3m.es/~assman/em/]
EMT: The Environment Maintenance Tool (EMT) was developed as a control mechanism for software development at Carnegie Mellon. It allows developers to create and maintain their own development areas. Using Depot, EMT also ensures that as developers release their software for general use that all naming conflicts with other sofware collections must be resolved.
Many of the operations that EMT allows developers to perform would normally be limited to system administrators. In order to avoid this, EMT checks the users authentication and then communicates with an ADM server to perform the requested operations on behalf of the user. In this way, developers are allowed access to a limited subset of the system administrator's privileges and so system administrators are freed from almost all of the chores involved in supporting software development.
[http://andrew2.andrew.cmu.edu/emt/emt.html]
EMTOOL: A program for interactive image processing primarily intended for those engaged in transmission electron microscopy. EMTOOL allows for the highly interactive manipulation of such parameters as brightness and scale as well as various manipulations such as translating, rotating, filtering, and converting image formats. It is designed for generic 2-D image processing and for preprocessing images for 3-D analysis, although it is not a 3-D reconstruction package. The features include online help, multiple open image windows, automatic byte order correction, reading and writing several image formats, and more. There are tools for the interactive boxing of particles from micrographs or micrograph fragments and for manipulating the box database so the same particles can be easily boxed from a focal pair.
The tools menu in EMTOOL encompass such functionality as:

trimming the edges of a histogram,

averaging two or more images together,

generating a mean power spectrum from a set of particle images using an FFT,

applying high or low pass filters to images,

normalizing images by setting the mean grey value to zero,

edge normalizing images,

subtracting two data sets,

flipping images vertically,

flood filling the edge of an image to change the mask color,

masking the center of an image,

padding an image for an FFT,

taking an FFT of an image (and the inverse operation),

taking the discrete wavelet transform of an image (and the inverse), and

wavelet filtering of images.

An experiment CTF menu includes tools for: rotating or translating an image by an arbitrary amount, calculating a cross correlation function between an image and the same image rotated 180 degrees, calculating the cross correlation of two different images, determining the rotational misalignment between two data sets via a rotational correlation function, and rotationally align two or more data sets.
Binary versions of EMTOOL are available for SGI IRIX and Linux Intel platforms. Documentation is available in HTML format.
[http://ncmi.bioch.bcm.tmc.edu/~stevel/emtool/]
Emu: A collection of software tools for the creation, manipulation and analysis of speech databases. The core of the package is a database search engine for finding speech segments based on the sequential and hierarchical structure of the utterances in which they occur. A set of graphical tools are also provided for constructing and using speech databases:

Labeller, which supports the display of speech data and allows annotation with segmental and event labels at any level of detail, and with hierarchical descriptions of the utterance as a whole;

Query Tool, a tool for constructing utterance lists (i.e. database subsets) to be used in searches, for saving segment lists in text files, and for viewing individual utterances or segments; and

Utterance List Editor, for creating, saving and reloading lists of utterances that define subsets of the database.

The Emu system can be modified and extended via writing scripts in Tcl, with several extensions for creating and manipulating the central Emu data structures already implemented. The source code for the package is available as is an extensive manual.
[http://www.shlrc.mq.edu.au/emu/]
Emu/fdtd: An electromagnetics simulator that uses the finite difference time domain (FDTD) method to solve Maxwell's equations in the time domain. It features an X/Motif GUI, a wide frequency range, 100 user defined electromagnetic materials, the capability of modeling any arbitrary 3-D layout of materials modeled in a simple cartesian mesh, sinusoidal and gaussian stimuli, absorbing boundary conditions and perfect electrical conductors, and much more.
A binary of Emu/fdtd is availablel for Linux/Intel platforms. Its use on one or more such platforms requires the installation of PVM and XPVM. A user guide is available in both PostScript and HTML formats.
[http://www.brunel.ac.uk:8080/depts/fdtd/]
emulators: An emulator is a program that runs on one type of hardware/operating system combination and emulates another type in software. Programs that emulate various computer or CPUs include:

Acorn Atom Emulator, for the Acorn Atom computer;

ALEC64, for the Commodore C64;

Apple II+ Emulator, for the Apple II+ computer;

arcem, for the Acorn Archimedes computer;

BSVC, for the Motorola 68000 processor;

DOSEMU, for the DOS operating system;

EM86, a Linux Intel emulator for Linux Alpha;

Euphoric, for the ORIC computer;

executor, for the Mac operating system;

fMSX, for MSX* computers;

Frodo, a C64 emulator;

M2000, for the P2000 computer;

Pfau Zeh, for the Commodore VIC-20;

PSIM, a PowerPC instruction set emulator;

QLAY, for the Sinclair QL computer;

SimCoupe, for the SAM Coupe computer;

SIMH, for PDP-8, PDP-11, PDP-1, Nova, and IBM 1401 computers;

tkisem, for the SPARC instruction set;

UAE, for the Commodore Amiga;

VICE, for 8-bit Commodore machines;

Vision-8, for the CHIP-8 system;

vMac, for the Motorola 68000-based Mac Plus;

VPCE, for the NEC PC-Engine console;

WINE, for MS Windows;

Xbeeb, for the Acorn BBC computer;

xcopilot, an emulator for the PalmPilot;

XGS, for the Apple IIGS;

Z80Em, for the Z80 microprocessor; and

XZX, for the Sinclair ZX Spectrum computer.

Programs that emulate various computer gaming systems include:

ADAMEm, emulates the Coleco ADAM and ColecoVision systems;

Atari800, for the Atari 800, 800XL, 130XE, and 5200 game machines;

ColEm, for the ColecoVision game system;

Handy, for the Atari Lynx game machine;

iNES, for the Nintendo Entertainment System (NES);

MAME, for arcade gaming machines;

MasterGear, for the SEGA MasterSystem and GameGear;

MESS, which can emulate several game systems;

NESstra, an NES emulator;

Replay+, for Arcade games;

Snes9X, for the Super Nintendo Entertainment System (SNES);

SNES9EXPRESS, a graphical front-end for Snes9X;

Stella, for the Atari 2600;

STonX, for the Atari ST;

System16 for the Sega System16 arcade machines;

TrueReality, a Nintendo 64 emulator;

VGB, for the Nintendo GameBoy video game;

Virtual 2600, for Atari 2600 game machines;

XNes, for the Nintendo Entertainment System (NES).

[http://www.uruk.org/~erich/emu/main.html]
[http://www.comlab.ox.ac.uk/archive/other/museums/computing.html]
[http://www.cs.man.ac.uk/CCS/]
emu10k1: A Linux device driver for the Soundblaster Live soundcard.
[http://www.opensource.creative.com/]
EMULib: A set of C library modules for use in writing computer emulators. Some emulate various computers chips, while others are used to play sound, handle data files, and work with hardware. The components of EMULib include:

SN76489, emulates the TI SN76489 sound chip;

TMS9918, emulates the TI TMS9918/TMS9928 video controller;

GBCarts, routines for working with GameBoy ROM images;

NESCarts, routines for working with NES/Famicon ROM images;

MIDI, routines for writing MIDI files;

SndUnix, sound generation for UNIX;

SndMSDOS, sound generation for MS-DOS;

SndWin, sound generation for Windows;

LibUnix, miscellaneous useful UNIX routines;

LibMSDOS, useful MS-DOS routines; and

LibWin, useful Windows routines.

[http://www.komkon.org/fms/EMUL8/]
EMUTools: A set of utilities for working with ROM images, playing and converting soundtrack files, disassembling programs, and performing various other tasks required for constructing emulators for old computer systems. The tools include:

bdiff, compares two binary files and prints the differences side-by-side in hexadecimal and ASCII;

undouble, checks if a file contains doubled copies of the same data;

dasm6502, a 6502 disassembler;

dasmz80, a Z80 disassembler;

gbdasm, a GameBoy disassembler;

gblist, processes GameBoy ROM images;

neslist, processes NES ROM images;

fdslist, lists the contents of Famicom DiskSystem disk images;

psgplay, plays several kinds of sound files; and

snd2mid, converts from the .SND format into .MID format.

[http://www.komkon.org/fms/EMUL8/]

Next: En-Ez Up: Linux Software Encyclopedia Previous: Dn-Dz Contents

Manbreaker Crag 2001-03-08