Next: Un-Uz Up: Linux Software Encyclopedia Previous: Tn-Tz Contents

Ua-Um

Last checked or modified: Oct. 13, 1998

UAE: A mostly complete software emulator for the Commodore Amiga computer, i.e. a 16/32 bit system based on the Motorola 680x0 CPU and a few specially designed custom chips which provide good graphics and sound capabilities. This can be compiled and used on most UNIX flavors including Linux Intel.
[http://www.freiburg.linux.de/~uae/]
[http://sunsite.unc.edu/pub/Linux/system/emulators/commodore/]
ubiqx: A set of utility modules written in ANSI C. The modules currently (6/98) available include:

lists, queues and stacks;

binary trees including unbalanced binary, AVL height-balanced, and splay trees;

a generic cache system that keeps track of the amount of memory in use, keeps a cache hit ratio, and automatically trims back the cache if it gets larger than a specified amount;

database modules that supply APIs for three types of table or database managers including a key-access DB, a descendant type of the key-access DB that adds support for sorted-order keys, and another descendant type that allows multiple sets of data to exist in the same database;

database implementation modules that provide the glue between the DB modules and the actual table manager or database.

A source code distribution is available that is supposed to compile on any platform with an ANSI C compliant compiler.
[http://www.ubiqx.org/]
[http://www.interads.co.uk/~crh/ubiqx/]
UCBTEST: Software for testing various difficult cases of IEEE 754 floating-point arithmetic.
[http://www.netlib.org/fp/]
UCData: A package for working with Unicode character properties that supports ctype-like operations for Unicode UCS-2 text (and surrogates), case mapping, decomposition lookup, and provides a bidirectional reordering algorithm. The character information part of the program consists of:

ucgendat, a program that generates data files from the main Unicode data file icluding case mappings, character property tables, character decompositions, non-zero combining classes, and codes representing numbers;

ucdata.[ch] files which implement the functions needed to check if characters match groups of properties; and

UCData.java, a Java class providing the same API as the C code.

Also provided is an alternative to the Unicode Bidi algorithm that demonstrates an effective alternate method for implicit reordering.
[http://crl.nmsu.edu/~mleisher/ucdata.html]
UCD-SNMP: A collection of tools relating to SNMP including an extensible agent, an SNMP library, tools for requesting or setting information from SNMP agents, tools for generating and handling SNMP traps, a version of the netstat command that uses SNMP, and a Tk/Perl MIB browser. This was originally based on the Carnegia-Mellon SNMP implementation (version 2.1.2.1) but has been modified to the extent that it no longer resembles it.
[http://ucd-snmp.ucdavis.edu/]
uClinux: A port of Linux 2.0 to systems without a Memory Management Unit (MMU), with only Motorola MC68000 derivatives currently (12/99) supported.
[http://www.uclinux.org/]
UCM: The UNIX Code Management systems provides tools for a UNIX-based code management system. It was originally designed for High Energy Physics (HEP) experiments but is more widely applicable. It consists of two parts: UNIX Version Management or UVM and a text preprocessor KPP. KPP functions much like the C preprocessor cpp but differs in that KPP is language insensitive and can be used to add include files and conditional lines to any text files. It is intended as a simple method for dealing with software which is system or platform dependent.
UVM consists of a number of Perl programs for creating and maintaining source libraries. It is an alternative to CVS and, like CVS, uses RCS files and related commands as the basic version management system in addition to providing tools for organizing RCS files into modules and libraries. UVM differs from CVS in that the former imposes sequential code development while the latter encourages concurrent development. UVM consists of four basic components:

UVMI, a set of commands for collecting information about UVM libraries and their contents;

UVMA, which provides the commands for creating and modifying the contents of the libraries;

UVMHTML, which provides a mechanism for accessing UVM library and element information via the Web; and

UVMBLD, a tool for building Makefiles from UVM library elements.

The UVM components of UCM can be used on any platform on which Perl and RCS or CVS are already installed. KPP is written in C and should compile on most generic UNIX platforms. Complete documentation is contained in the distribution in HTML format.
[ftp://ftp.fnal.gov/pub/ucm/]
UCM (notation): Use Case Maps is a notation used to describe and understand emergent behavior of complex and dynamic systems. UCMs have been used for the requirements engineering and design of real-time systems, object-oriented systems, telecommunication systems, distributed systems and agent systems. See Buhr and Casselman (1996).
[http://www.UseCaseMaps.org]

UCMNAV

The UCM NAVigator is a tool for creating and modifying UCMs. It is designed to handle any valid UCM as well as software components and is capable of binidng these UCM elements to components. It can also create multi-level maps in which submaps of a lower level are expressed as stubs in a higher-level map. The editor supports nested levels up to 10 deep and is capable of generating a textual EBNF linear form which can be used as input to other tools such as Agent generation tools and performance simulators. Binaries are available for Linux Intel, HPUX and Solaris systems.
[http://www.UseCaseMaps.org/UseCaseMaps/tools/ucmnav/]
uC++: An object oriented programming language with high-level concurrency that extends C++ with new constructs that provide lightweight tasks on shared-memory uni- and multi-processors running the UNIX operating system. This was developed as a higher-level alternative to using complicated and error-prone POSIX threads and locks. It is implemented as a translator that reads a program containing the extensions and transforms each into one or more C++ statements which are then compiled by a C++ compiler and linked with the uC++ concurrent runtime library.
The uC++ extensions provide:

concurrency at the level of active objects with capabilities including statically type-safe communication,

direct and indirect communication,

the ability to postpone requests without inhibiting concurrency,

coroutines,

clustering of tasks and processors, and

a highly concurrent non-blocking I/O library.

Recent extensions include real-time capabilities and extended exceptions and asynchronous signalling capabilities for constructing robust concurrent programs.
The uC++ language extensions are available in source code form and currently run on i386, Sparc, M68K, MIPS, Alpha, RS6000, and HP-PA architectures on Sequent, Sun, DEC, SGI, IBM, HP and Linux systems. The documentation is contained without a user's guide and several technical reports available at the site in PostScript format.
[http://plg.uwaterloo.ca/~usystem/]
ucppkit: The name of this package has been changed to nb++.
uCR: An embedded operating system suitable for use in environments where traditional operating system behavior is either too confusing or too expensive or impossible due to hardware limitations. The uCR OS requires only a CPU and a small amount of RAM, although a means of getting memory written can be helpful. It is intended to not completely hide the hardware from the programmer, and the execution model is simplified as much as possible to give the programmer much more control over the machine than with a typical OS. The basic uCR environment uses widely available tools for cross-compilatoin, assembly, and linking, and should be easy to port to a wide variety of platforms. It supports both C and C++ code development.
The uCR execution model supports a single C++ task with many threads. On CPUs which support multiple protection models applications run in the most privileged mode with interrupts enabled, and means for protecting critical sections of code from interruption and for managing the execution of threads are provided. It doesn't explicitly support multiprocessors but this can be accomplished by running a uCR application in each processor and providing drivers for the hardware IPC to allow the applications to communicate. In the memory model all memory is shared as are devices and any other resources in the machine. No paging support or protection models are required or implied, with the layout of memory being exactly that designed into the hardware.
The source code for uCR is available under the GPL. It can be compiled using the standard GNU tools, e.g. gcc, binutils, and make. The currently (5/97) available targets are i960_cyclone and i960_ise. Significant portions of uCR can be used without special hardware and run on virtual targets, e.g. Linux processes. A user's manual is available in HTML format. See the Linux Lab Project for similar tools.
[http://www.picturel.com/software.html]
ucspi-tcp: A pair of command-line tools for building TCP client/server applications. The tcpserver program:

waits for incoming connections and runs a chosen program for each connection, providing that program with environmental variables showing the local and remote host names, IP addresses and port numbers;

provides a concurrency limit to forestall running out of processes and/or memory;

provides TCP access control features similar to but faster than those of TCP wrappers; and

includes a recording tool for monitoring the I/O of a server.

The tcpclient program makes a TCP connection and runs a chosen program (while providing the same variables as tcpserver). The package also includes several simple clients built on top of tcpclient including who, date, finger, http, tcpcat and mconnect.
[ftp://koobera.math.uic.edu/www/ucspi-tcp.html]
ud: The uptime daemon runs as a daemon in the background and records uptimes. It reads a template file to create an HTML output file that can be perused via the Web. See the similar uptimed.
[http://www.vistasafe.com/ud/]
UDC: A Fortran 77 implementation of a divide-and-conquer method for computing the spectral resolution of a unitary upper Hessenberg matrix. Any such matrix of order N - normalized so that its subdiagonal elements are nonnegative - can be written as a product of N-1 Givens matrices and a diagonal matrix. This representation - called the Schur parametric form - arises in applications such as signal processing and the computation of Gauss-Szego quadrature rules. This package uses the Schur parameterization to compute the spectral decomposition of a unitary upper Hessenberg matrix without explicitly forming its elements. This is TOMS algorithm 730 and is documented in Ammar et al. (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
UDF: The Universal Disk Format is a new CD-ROM filesystem standard required for use with DVD-ROMs. It is meant to be a replacement for the ISO-9660 filesystem currently in use on CD-ROMS, although it will have more of an impact on DVDs since it will be used to contain MPEG audio and video streams on them. Accessing DVDs on a Linux box requires a DVD drive, the kernel driver for the drive, MPEG support, and a UDF filesystem driver.
[http://trylinux.com/projects/udf/]
[http://www.bitwizard.nl/udf/]
[http://www.videodiscovery.com/vdyweb/dvd/dvdfaq.html]

udf

A project to incorporate support for the UDF filesystem format into the Linux kernel.
[http://trylinux.com/projects/udf/]
UdmSearch: The name of this package has been changed to mnoGoSearch.
UDO: The Universal DOcument is both a format and a software that can convert UDO format into other formats including: Apple QuickView, ASCII, HTML, LaTeX, Linuxdoc-SGML, Lyx, man page, nroff, Pure C Help, RTF, source code (C and Pascal), ST-Guide, WinHelp, Texinfo, and Turbo-Vision-Help. The syntax for the Universal Document Format (UDF) resembles a combination of LaTeX and ST-Guide or AMiga-Guide.
The capabilities of UDO include:

complete document layout;

including enumerated or descriptive lists;

the automatic conversion of special characters;

the insertion of hypertext links when converting to HTML and other formats;

enumerating chapters and creating tables of contents;

the use of different text styles (e.g. bold, italic, footnotes, centering, etc.);

graphics inclusion of HTML, LaTeX and other formats; and

tables.

The UDO package is available in binary format for TOS, DOS, Linux Intel, HP-UX, Mac, BeOS, SINIX, NeXTStep, and Sun SunOS platforms. It is written in C and therefore highly portable. The documentation is currently (4/97) available in HTML format. UDO is shareware with a license fee of $35 U.S. for private users to run it on any system(s) they wish.
[http://members.aol.com/DirkHage/gt/udo6.html]
UDP: The User Datagram Protocol is an alternative protocol to TCP that is used when the complexity of the latter is not required. Among other things, TCP breaks messages into datagrams and also reassembles them. UDP is designed for applications such as name lookup that require only a single datagram and thus don't need the complexity and accompanying extra overhead of TCP. The UDP process begins with the network software putting a UDP header on some data. It then sends the data to IP which adds an IP header with the UDP protocol number in the protocol field. Unlike TCP, all UDP provides are source and destination port numbers and a checksum, i.e. it doesn't split the data into multiple datagrams and doesn't keep track of what has been sent. This allows several programs to use UDP simultaneously. It is used mostly by protocols that handle name lookups. A related and even simpler protocol used for error and other message intended for the TCP/IP software itself is ICMP, which additionally omits the port numbers in its header. See Hall (2000).
[http://www.faqs.org/rfcs/rfc768.html]
udunits: A library for manipulating units of physical quantities. It supports the conversion of unit specifications between formatted and binary forms, the arithmetic manipulation of unit specifications, and the conversion of values between compatible scales of measurement.
The udunits package includes the library, a utility program, and an extension that allows Perl to be used as a front end. The documentation is contained within man pages included in the distribution. It is available as source code or in binary form for several platforms, including Linux.
[http://www.unidata.ucar.edu/packages/udunits/index.html]
UESQLC: An Open Source embedded SQL-92 precompiler for C++. This was designed to be extensible using SGML documents. It allows accessing multiple relational database management systems from a single application, and can verify the three levels of SQL conformance. The distribution contains SGML documents that target the Oracle Server 8.x OCI and PostgreSQL 6.2.x LIBPQ programming interfaces. New targets can be created simply by writing a new SGML document, with no recompilation required.
[http://www.hipernet.es/~ralcan/uesqlc/]
UfMulti: A distributed data analysis toolkit which provides tools and function calls that allow monolithic data analysis programs to be broken up into logical distributed pieces and operated in parallel on multiple hosts. It also operates dynamically based on system load. It speeds up a single application by distributing it across many CPUs with as little extra user coding as is possible. Interfaces to both Fortran and C are provided. Features of UfMulti include high data throughput, dataset files support, statistics collection, non-event records, allocation of CPU and disk resources, reasonable fault tolerance, and monitoring tools.
The UfMulti distribution includes the source code which is written in C. It can be compiled and installed on any standard UNIX workstation with TCP/IP network protocols. The documentation is contained within a 70+ page user's manual available in PostScript format.
[http://quark.phys.ufl.edu/~ufm/]
UFO: The United Functions and Objects project aims to develop a programming language which unites functional and object-oriented programming techniques to ease the task of developing programs for parallel machines. A large subset of UFO is a pure, higher-order functional language that incorporates the OO notions of classes, inheritance, and dynamic binding. Also provided are multi-dimensional arrays with integrated loop structures and monolithic operators designed for scientific applications. It departs from a pure functional language in that it includes stateful objects to allow programs to be written in a concurrent object-oriented style when needed. Parallelism by default is an overriding design principle wherein the language doesn't enforce any specification of sequencing other than that required to maintain coherent access to stateful objects.
The UFO distribution is avaiable upon request. It consists of a compiler (written in UFO), a browser tool, an interpreter, a translator from SISAL to UFO, several analysis tools, and various numeric and other examples. The current (11/98) implementation is sequential and generates ANSI C. A user's manual and a language reference manual are part of the available documentation suite.
[http://www.cs.man.ac.uk/arch/projects/ufo.html]
UG: A flexible toolbox for the adaptive multigrid solution of partial differential equations. Features include several problem classes provided with current distribution, support for unstructured meshes with local refinement and coarsening in 2-D and 3-D, an interactive GUI for X11, a flexible scripting langauge, an advancing front grid generator in 2D, and about 1000 pages of online and PostScript documentation.
[http://www.ica3.uni-stuttgart.de/~ug/]
Ultra Monkey: A project to build a high availability and load balancing solution for Linux. The current (11/00) focus is on producing a scalable, highly available web farm, although the technology is easily expandable to other services. The features include:

layer 4 switching using the Virtual Server Project;

easy expansion to a large number of IP-based virtual services;

high availability provided by the Heartbeat protocol of the High-Availability Project;

service level monitoring using ldirectord; and

support for highly available and/or load balanced topologies.

[http://ultramonkey.sourceforge.net/]
UltraScan: A comprehensive data analysis tool for hydrodynamic studies of macromolecules and macromolecular assembles. The main focus is on analytical ultracentrifugation experiments, although capabilities for the integration of quasi-elastic laser light scattering experiments are also available. The goal is to provide an intuitive GUI providing an integrated data editing and analysis environment. The general features include:

fast, efficient and easily-applied algorithms;

an interface that is useful for both the beginning user just learning how to use it and the advanced user who wishes to analyze vast amounts of data in the shortest possible time;

automation of every amenable task with only those that cannot be predicted a priori left to the user; and

diagnostic and error checking capabilities to assure that incorrect user actions are caught and clearly indicated and that warnings are provided to assist the user in the correct interpretation of results.

The functionality of UltraScan II includes:

various finite element simulations including non-interacting w/ unlimited components, Monomer-Dimer self-associating systems, isomerizing equilibrium with two states, user selectable models, and concentration dependency of sedimentation and diffusion;

various experimental data analysis methods including van Holde-Weischet, second moment, dC/dt, dC/dr, and a whole boundary fitting method based on the approximated solutions of Fujita and McCosham;

equilibrium analysis via global fitting of multiple scans incorporating multiple wavelengths, multiple scans, multiple concentrations, and multiple speeds for several models including single ideal and non-ideal systems, self-associating systems involving up to 3 species, and non-interacting systems with up to 2 species; and

several useful utilities.

Binary distributions are freely available for several UNIX flavors including Linux Intel. The source code is also available upon request of the author. Documentation includes both a user's manual and an extensive FAQ.
[http://biochem.uthscsa.edu/UltraScan/]
UltraSonix: A project to provide access to X Windows applications for the blind by transforming the graphical interface into an interactive auditory interface. It provides speech and non-speech auditory representations of the applications on an X desktop, and can also generate Braille output of text areas. It can synthesize the input that applications expect (i.e. mouse clicks and key presses) from alternative input sources.
[http://henge1.henge.com/~brian/ultralin.html]
[http://trace.wisc.edu/world/computer_access/pusl/]
UMFPACK: The Unsymmetric-pattern Multi-Frontal PACkage solves the linear system Ax=b using LU factorization where A is a general unsymmetric sparse matrix. This method factorizes a large sparse matrix using a sequence of small dense front matrices with the latter factorized using dense matrix kernels. UMFPACK uses dynamically constructed rectangular frontal matrices to allow it to extend classical multifrontal methods to matrices with nonsymmetric zero patterns.
Features of UMFPACK include options for choosing a good pivot order, factorizing a subsequent matrix with the same pivot order and nonzero as a previously factored matrix, solving systems of linear equations with the calculated factors, and iterative refinement with sparse backward error estimates. Single and double precision versions of the routines are available.
The source code, written in Fortran 77, is available along with an installation guide and several technical papers in PostScript format. UMFPACK requires the BLAS package as well as a couple of routines from HSL MA28 package found at Netlib.
[http://www.cis.ufl.edu/~davis/]
[http://www.netlib.org/linalg/]
UMK: The User-Mode Kernel is a Linux kernel ported to its own system call interface such that it runs in user-mode in a set of processes. The UMK root filesystem in contained in a file in the underlying filesystem, and the console is the window from which it was run. This virtual machine is useful for applying process-level tools to kernel development like debugging, profile and code coverage analysis. This requires kernel 2.2 or higher and is available as an executable or as a kernel patch.
[http://www.mv.com/ipusers/karaya/uml/uml.html]
UML: An industry standard language for specifying, visualizing, constructing and documenting the artifacts of software systems. It can also be used for modeling businesses and other non-software systems. It represents a collection of the best engineering practices that have been successful in modeling large and complex systems. The official UML specification consists of two parts:

UML Semantics, a metamodel that specifies the abstract syntax and semantics of UML object modeling concepts; and

UML Notation, a graphic notation for the visual representation of the UML semantics.

The official documentation is available in various formats. See also Booch et al. (1998), Conallen (2000), Jacobson et al. (1999), Fowler et al. (1997) and Fowler et al. (1998).
[http://www.rational.com/uml/]
[http://www.ics.uci.edu/pub/arch/uml/research/]
UM-LDAP: An implementation of the Lightweight Directory Access Protocol (LDAP which can be used to provide a stand-alone directory service or lightweight access to the X.500 directory. The UM-LDAP package includes several components including:

slapd, a stand-alone LDAP directory server;

slurpd, a stand-alone LDAP replication server;

ldapd, an LDAP-to-X.500 gateway server;

centipede, an LDAP centroid generation and maintenance program;

libldap, and LDAP client library;

liblber, a lightweight BER/DER encoding/decoding library;

ldif, data conversion tools for use with slapd;

in.xfingerd, a finger-to-LDAP gateway server;

go500, a gopher-to-LDAP gateway server for searching;

go500gw, a gopher-to-LDAP gateway server for searching and browsing;

rcpt500, an email-to-LDAP query responder;

mail500, an LDAP-capable mailer;

fax500, an LDAP-capable mailer which supports remote printing;

a collection of shell-based LDAP utility programs;

web500, an HTTP-to-LDAP gateway;

whois++d, a WHOIS++-to-LDAP gateway; and

saucer, a simple command-line oriented client program.

The slapd directory server can be used to provide a directory service with several features including:

a choice of three different backend databases (i.e. LDBM, a disk-based database; SHELL, a database interface to arbitrary UNIX commands or shell scripts, and PASSWD, a simple password file database);

configurability to simultaneously serve multiple databases;

a generic database API which allows you to write your own backend databases;

a powerful access control facility which can control access based on several criteria;

use of threads for high performance with a single multi-threaded process handling all incoming requests;

configurability to maintain replica copies of the database; and

high configurability in just about every aspect of its use.

A source code distribution of UM-LDAP is available. It is written in C and has been ported to most flavors of UNIX including Linux. It is documented in a user's guide for slapd and slurpd as well as with man pages for each of the programs.
[http://www.umich.edu/~dirsvcs/ldap/ldap.html]

ldapmodule

A Python interface to the UM-LDAP library.
[http://www.it.uq.edu.au/~leonard/dc-prj/ldapmodule/]
UMPE: The University of Miami Parabolic Equation model is a Fortran code for solving the acoustic wave equation using the parabolic approximation. The UMPE model:

treats the bottom as a fluid whose sound speed and density differs from that of water;

allows for an additional bottom layer to exist on top of the basement to allow for sediment layer effects to be included;

treats the surface as a perfect reflector due to a pressure release boundary, i.e. a Dirichlet boundary condition;

includes the effects of volume attenuation via the inclusion of a complex index of refraction;

uses an empirically derived formula for water volume attenuation;

allows the specification of a volume attenuation coefficient for each bottom profile, i.e. it may be range dependent but is constant over the depth of the bottom layer;

treats the conversion process of compressional to shear waves at the bottom interface as a loss term;

allows forward scattering from a rough water/sediment interface;

allows either approximate or exact surface forward scattering;

allows for the scattering effects of near-surface bubbles;

can compute acoustic particle velocities from the pressure field; and

calculates transmission loss at a fixed depth or to the surface.

A source code distribution of the UMPE model is available. It is written in Fortran 77 and is documented in an 80+ page user's guide and reference manual in PostScript format. This is being superseded by MMPE.
[ftp://oalib.njit.edu/pub/UMPE/]
UMPRS: A general purpose agent architecture that supports top-down, goal-based reasoning and selects goals and plans based on maximal priority. UMPRS is a BDI-theoretic (Belief-Desire-Intention) agent architecture based on a PRS (Procedural Reasoning System) wherein the concepts are explicitly represented within the agent code such that when you implement agents you specify beliefs (facts known to the agent), desires (goals for the agent to achieve), and capabilities (plans and primitive actions) with intentions dynamically determined by the agent at runtime based on its known facts, current goals, and available plans.
UMPRS supports the execution of multiple simultaneous goals with suspension and resumption capabilities for each goal or intention thread. Plans have an integrated precondition/runtime attribute that constrains their applicability with several plan constructs including sequencing, iteration, subgoaling, atomic blocks, n-branch deterministic conditional execution, explicit failure-handling section, and C++ primitive function definition. A source code distribution of this C++ package is available. A user's manual is available in HTML format. This is related to the Jam! package.
[http://members.home.net:80/marcush/IRS/]
UMT: The Ultimate Mail Tools is a mail user agent (MUA). The features include:

a Rich Text (RTF) message editor and viewer which allows the use of different colors and fonts in e-mail,

MIME 1.0 support;

secure MIME support;

multilanguage support;

a user-friendly graphical user interface;

compatibility with POP v3;

an address book in which e-mail addresses can be stored;

intelligent filters which can be created by filling in a simple GUI form; and

a flexible configuration file.

A source code distribution of UMT 1.0B3 is available as are binaries for Linux Intel (ELF and a.out) and a couple of other UNIX platforms. The documentation is a bit scattered and sparse.
[http://www.crocodile.org/UMT/UMT.html]
[http://sunsite.unc.edu/pub/Linux/system/mail/mua/]

Next: Un-Uz Up: Linux Software Encyclopedia Previous: Tn-Tz Contents

Manbreaker Crag 2001-03-08