Next: Vn-Vz Up: Linux Software Encyclopedia Previous: Un-Uz Contents

Va-Vm

Last checked or modified: Oct. 13, 1998

V (GUI builder): A portable C++ GUI framework intended for the development of a wide variety of applications on different platforms. Applications developed using V will have the look and feel of the native platform yet still be portable across platforms. At the time of writing (2/96) V supports X11 using the Athena (Xaw) widgets and Windows 3.1, although versions for Motif, Windows 95 and OS/2 are being developed. Most of the standard GUI objects are supported by V including windows with menus, status bars, tool bars, a drawing canvas, modal and modeless dialogs with th emost common controls (e.g. buttons, lists, labels, text entry, check and radio buttons, etc.), and portable printing support.
The features supported by V include:

command windows with pull-down menus, a drawing canvas with colors, brushes and pens, drawing shapes, text in various native fonts, icons and bitmaps, mouse and keyboard, a command/tool bar and a status bar;

modal and modeless dialogs with platform independent layout control, the most common controls/widgets including push buttons, blanks, check boxes, color buttons, combo boxes, frames, icons, icon buttons, labels, lists, progress bars, radio buttons, sliders, spinners, text input and output, etc.;

platform independent printer support with PostScript for X, standard Windows printers, portable treatment of fonts, and the same drawing support as the drawing canvas; and

timers and utility dialogs.

The X version was developed using the GCC/G++ compiler and has been tested on Linux, SunOS, and SGI machines, while the Windows version has been tested on both Windows 3.1 and 95. A 150 page indexed manual is included in both LaTeX and PostScript formats. An OpenGL add-on is in the works.
[http://www.objectcentral.com/]
V (MR): A general purpose software system for magnetic resonance imaging and spectral reconstruction, processing, and analysis. V contains a selection of popular reconstruction tools and is aimed at providing a means for the distribution of such functions among interested researchers. To aid in this goal it has been designed such that software development doesn't require thorough knowledge of the internals of V.
The capabilities of V include:

multidimensional Fourier and wavelet transforms;

RIGR, TRIGR, and Keyhole constrained dynamic image reconstruction;

the phase unwrapping algorithm;

spectroscopic baseline correction and parameter estimation routines;

the half-Fourier (or half-echo) reconstruction algorithm;

linear prediction algorithms including HPSVD and HSVD;

canny edge detection;

a wide selection of basic math operations;

handling several formats including HDF, SISCO, ASCII, and several raw data formats;

several data manipulation functions including intensity scaling, geometric manipulation, dimension reordering, and data padding and extraction;

image display via 1-D and stacked plotting;

movie creation (via additional software);

on-line documentation;

macros and various linear algebra tools; and

extensive examples with associated data.

A source code distribution of V is available. Is is written in Fortran and C and has been designed for compilation with gcc and g77. The xv package is used for image and plot display, and various MPEG tools such as mpeg_play and mpeg_encode are used for animations. A user's guide and various other documents are available in PostScript format.
[http://motion.brl.uiuc.edu/]
Vanilla: An implementation of a configurable mixed-media file system, where configurable means that a file system serving a specific application area can be realized out of a library of reusable file system classes, and mixed-media means the system's ability to integrate different media types (e.g. RAM, hard disks, WORM optical disks, CD-ROMs, tape devices, RAID arrays, etc.) into a virtual storage system by masking the details from applications. A prototype C++ implementation of Vanilla is available.
[http://www.softwired.ch/people/maffeis/vanilla.html]
VarDen: A library of C++ classes for simulating the Variable Density incompressible Navier-Stokes equations on a single rectangular grid. This uses a single grid version of the variable density projection method using upwind Godunov methodology and an approximate projection to solve the governing equations. Both 2- and 3-D versions of VarDen are available.
The classes for 2-D VarDen include:

Grid, which handles the time-stepping;

diffuser, a class for diffusive/viscous problems;

diffuser_mg, a multigrid solver for diffusive/viscous problems;

hgprojection_mg, a multigrid solver for nodal projection;

macprojection_mg, a multigrid solver for MAC projection; and

multigrid, a multigrid class.

The 3-D classes are similarly named if slightly different in functionality.
Source code distributions of VarDen are separately available for the 2-D and 3-D versions. The packages are written in C++ and require the BoxLib package for compilation and use. Separate user's guides are available for both VarDen versions in PostScript format.
[http://seesar.lbl.gov/ccse/software/varden.html]
VARKON: A CAD system and high-level development tool for engineering, computer aided designed and product modeling applications. VARKON can be used as a traditional CAD system with drafting, modeling and visualization, but it is also a powerful parametric modeling and CAD applications development tool. It includes interactive parametric modeling in 2- and 3-D as well as MBS, a programming language designed for design and product modeling. Applications created using VARKON can:

perform any calculations;

retrieve data from external databases;

make decisions;

perform complex geometrical operations;

build object-oriented structures with attributes and geometry;

generate graphic images such as 2-D drawings and 3-D models with shading or removal of hidden lines; and

create any type of data file for output.

The geometric modeling capabilities of VARKON include:

a wide range of basic 3-D entities such as points, lines, arcs, curves, surfaces, coordinate systems and transformations;

several representations of parametric curves including rational polynomial, lofted procedural, analytical offset and a faceted surface for approximations;

various operations including intersects, closest point, silhouette, curvatures, transformation, trimming, export, import and approximation; and

basic visualization and complex rendering based on OpenGL.

Binary distributions of VARKON are available for Linux systems as well as (eventually) all the C source code under the GPL. Documentation includes a user's manual, an MBS programmer's manual and several demo applications, all available in HTML format.
[http://www.microform.se/]
vat: An audio tool which is a real-time, multi-party, multimedia application for audio conferencing over the Internet. Vat is based on the RTP Draft Internet Standard where RTP is an application-level protocol implemented entirely within vat, i.e. no special system enhancements are needed to run it. It can be run point-to-point using standard IP addresses, but it is primarily intended to be a multiparty conferencing application. Your system must support IP Multicast to make use of the conferencing capabilities and ideally should be connected to the IP Multicast Backbone, i.e. MBone. Vat provides only the audio portion of a multimedia conference with the video handled by vic, the whiteboard by wb, and the session announcement tasks by sd.
The vat software is available in binary format for Sun SunOS and Solaris, DEC OSF and Ultrix, HP-UX, SGI IRIX, and Linux Intel platforms. The source code is also available and requires Tcl/Tk and GSM for installation. The standard OSS sound driver is required on Linux systems.
[http://www-nrg.ee.lbl.gov/vat/vat.html]
VAUL: The VHDL Analyzer and Utility Library is a VHDL front-end that aims to be complete, correct and flexible. VAUL can be used to parse and analyze arbitrary VHDL code and create an abstract syntax graph represented as a collection of C++ objects tightly connected by pointers. Source code distributions are available under the GPL. This may be included as the front-end in the FreeHDL project.
[http://www-dt.e-technik.uni-dortmund.de/~mvo/vaul/]
VAX: A Linux VAX port.
[http://ucnet.canberra.edu.au/~mikal/vaxlinux/home.html]
VBCTOOL: A graphical tool designed to draw binary and general rooted trees as they occur during an algorithmic process. VBCTOOL can be used for the simple drawing of trees, for drawing a tree during a computational process, or for emulating a tree growing process after the computation is finished. The features of the GUI include area zoom, mouse dragging, printing commands, and a chooser for colors, fonts, and sizes.
Binary versions of an executable as well as a library for adapting programs to the VBCTOOL interface are available for Sun SunOS and Solaris and Linux Intel platforms. A user's manual is separately available in PostScript format.
[http://www.informatik.uni-koeln.de/ls_juenger/projects/vbctool.html]
VBS: The Virtual Bulletin System is a bulletin board and conferencing system with several useful features including:

mostly compliant with the WWW CGI security FAQ;

storage of messages in raw database format with a customizable plug-in design;

an online Web administration tool;

group password capability for each subheading and message area;

heading/subheading/message editing;

administrative password protection;

indented replies and message threading;

realtime chat room capabilities;

multiple removes for easy administrative maintenance;

message board information;

multimedia sound embedding;

file uploading;

text search and replace; and

complete searchability of every board.

A source code distribution of VBS is available. Usage requires a browser with frames, forms, and Javascript. Several Perl modules are also required which can be found at CPAN.
[http://www.ameritech.net/users/bsd/index.html]
vcdfs: A package which can be used in conjuction with userfs to provide access to MPEG-1 content stored on White Book standard video CDs using IDE or SCSI CD-ROM drives.
[ftp://www.dvsystems.com/]
VCG: The Visualization of Compiler Graphs tool reads a textual specification of a graph and visualizes the graph. The features of VCG include:

visualization of large graphs automatically generated by other programs, e.g. debuggers of data structures;

several drawing modes for trading off between speed and fully complete and aesthetically pleasing visualizations;

a choice of 13 basic layout methods including a specialized version for trees and 4 variants of cross reduction as well as various optional optimization methods;

subgraph folding of dynamically specified regions and the hiding of classes of edges to select the most interesting parts of the graph;

arbitrary zooming of graphs with fully scalable loadable fonts and icons;

support for up to 254 colors;

a selection of different node shapes and edge types;

drawing edges as polygon segments or as splines;

orthogonal layout consisting of all horizontal and vertical edge segments;

export into PBM, PNM or PostScript formats;

fisheye views; and

an interface to program animations for sequences of graph descriptions.

A source code distribution is available under the GPL. Binary distributions are also available for a wide range of programs.
[http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html]
VCHE: A hex editor with which all 256 characters can be seen including control and extended ASCII characters. This uses the /dev/vcs[1-63] and /dev/vcsa[0-63] character devices to perform all screen I/O. The package contains X11, ncurses and raw versions of the program. The first version allows all characters to be seen, and the latter two only a limited subset. A source code distribution is available.
[http://www.grigna.com/diego/linux/]
VCR: An Internet-based distributed real-time MPEG video audio player. VCR plays MPEG-1 video and Sun SPARC audio across the Internet and features common VCR functions such as synchronized video and audio playback, play speed change on the fly, fast-forward, rewind, step forward, and random positioning. Other features include UDP/TCP video audio data connection choice and support for both the native audio device and AudioFile. A source code distribution is available as well as binaries for several platforms including Linux Intel.
[http://www.cse.ogi.edu/~scen/Player/]
VCS: A package for the selection, manipulation, and display of scientific data that can be run either interactively or via a script file. This package was designed to meet the needs of climate scientists who create gigabytes worth of output from climate model simulations and require powerful visualization tools to make sense of it all. The VCS data display model comprises levels of element sets, with the primary level elements being the data, a graphics method, and a picture template. Secondary elements are used to change the detailed specification of the attributes of the primary elements. These include the attributes of color, fill area, format, lines, markers, and text.
The capabilities of VCS include:

browsing data directories and quickly reading display variables from files in supported formats;

viewing, selecting and modifying attributes of data variables and their dimensions;

creating and modifying existing template attributes and graphics methods;

saving the system state as a script that can be run interactively or in batch mode;

saving a display as a CGM, raster or PostScript file;

performing grid transformations and computing new data variables;

creating and modifying colormaps;

zooming onto a specified portion of the display;

changing the orientation or size of a display;

animating a single data variable or more than one simultaneously; and

saving modified data variables in several formats.

VCS can read data in NetCDF, HDF, DRS, GrADS, or GRIB formats, and can save modified data in NetCDF, HDF or DRS formats.
Binary versions of VCS are available for Sun SunOS and Solaris, SGI IRIS, HP-UX, IBM AIX, DEC OSF, Cray and Linux platforms. The source code is also available under some circumstances. A tutorial and user's guide is available in both HTML and PostScript formats.
[http://www-pcmdi.llnl.gov/software/vcs/index.html]
VDT: The VHDL Developer's Toolkit was developed in C++ to support the fast and easy development and integration of VHDL application tools in an object-oriented manner. It provides a library of versatile routines and several utilities including:

a VHDL analyzer that parses VHDL codes and constructs their intermediate forms;

a VHDL generator that regenerates the corresponding VHDL codes from the given intermediate forms; and

a procedural interface through which applications tools can efficiently manipulate VHDL intermediate forms, i.e. a library of routines for handling the intermediate form.

Binary distributions of VDT are available for several platforms including Linux Intel.
[http://poppy.snu.ac.kr/VDT/]
VDX: A user interface management system (UIMS) for creating user interfaces with OSF/Motif widgets. The features of VDX include:

object-oriented handling including drag and drop;

an interactive WYSIWYG view;

a widget resource editor;

a widget tree browser;

widget tree templates;

reusable components;

automatic generation of C and C++ code; and

adaption of code generation.

A source code distribution is available under the GPL.
[http://www.bredex.de/vdx/]
vector_pade: A package for computing Pade-Hermite and simultaneous Pade approximants. This is TOMS algorithm 766 and is documented in Cabay et al. (1997).
[http://www.acm.org/calgo/contents/]
VerGO: A C++ library which allows the user to optimize a twice continuously differentiable function of any number of variables. It uses a combination of verified interval arithmetic and (if desired) automatic differentiation. It will solve such problems to any accuracy (within machine limits) and return a list of boxes which are guaranteed to contain the global optimum. This has advantages and disadvantages over simulated annealing, genetic algorithms, and local optimizers. The advantages are that it is guaranteed to find the global optimum of the function rather than returning either a probability or a good guess, that it finds all global optima and offers alternative solutions and that it can return answers relatively quickly on many problems as well as approximate answers quickly on most problems. The disadvantages include that it can take an extremely long time to verify a global optimum, that it can take a huge amount of memory, and that it can only handle white box functions, i.e. those representable by a piece of code on a computer. VerGO uses a branch-and-bound algorithm as its basic framework which is enhanced using other information about the functions such as monotonicity and concavity.
A source code distribution of VerGO is available. It is written in C++ and can be compiled on several types of platforms, including Linux Intel using gcc 2.6.3 or later. A user's manual is included in the distribution in PostScript format.
[http://www-math.cudenver.edu/~rvan/VerGO/VerGO.html]
VermelGen: A VRML 2.0 editor written in Java. It is a scenegraph editor that runs within the browser environment and is built on top of the JVerge class libraries. A source code distribution is available.
[http://www.vlc.com.au/VermelGen/]
Verse: A network protocol for a 3-D client/server graphics system designed to let anyone build and distribute a 3-D world on the Internet or any other TCP/IP network.
The functionality of the Verse server includes:

holding a world database organized into nodes;

accepting and executing commands to create, modify and delete nodes in the database as well as trigger object methods (i.e. calls to code associated with an object);

distribute changes to nodes to all subscribing clients; and

support various system maintenance commands via a fake node construct.

The Verse client functionality includes:

connecting to a server to subscribe to desired data;

rendering world representations;

providing a user interface for navigating and manipulating the world; and

receiving commands for updating the local world model.

[http://www.obsession.se/verse/]
VERTCON: A Fortran 77 program for computing the modeled difference in orthometric height between the North American Vertical Datum of 1988 (NAVD 88) and the National Geodetic Vertical Datum of 1929 (NGVD 29) for a given location specified by latitude and longitude.
[ftp://ftp.ngs.noaa.gov/pub/pcsoft/vertcon/]
Verus: A program for the formal specification and verification of real-time and other time critical systems. It can also be applied to untimed software and hardware applications. The system is specified using the Verus language which is compiled into a state-transition graph. Algorithms derived from symbolic model checking are then used to compute quantitative information about the model. A CTL (computational tree logic) symbolic model checker is also provided to asssist in the verification process. The language is designed to allow the straightforward description of the temporal characteristics of programs. The information produced allows checking the temporal correctness of the model, the schedulability of the systems tasks, and the analysis of the reaction times to the events. This provides insight into the behavior of the system and can identify where the design can be optimized. A source code distribution of this C program is available. Documentation is contained in a user's manual in PostScript format.
[http://www.cs.cmu.edu/~modelcheck/verus.html]
VFAT: A Linux filesystem compatible with Windows NT/95 long filenames on the FAT filesystem. VFAT does not read the NTFS filesystem. A source code distribution is available.
[http://bmrc.berkeley.edu/people/chaffee/vfat.html]
VE08AD: A Fortran 77 subroutine for minimizing partially separable objective functions with possible upper and lower bounds on the variables. The purpose of VE08AD is to minimize an objective function consisting of a sum of finite element functions, each of which involves only a few variables or whose second derivative matrix has a low rank for other reasons. Bounds on the variables and known values may be specified, and the routine is especially effective with problems involving a large number of variables. See () and ().
[http://www.netlib.org/opt/]
VFFT: A vectorized package of Fortran subroutines for the fast Fourier transform (FFT) of real number sequences. The real periodic transform is a variant of the Stockham autosort algorithm with no restriction on the sequence length. The other specialized transforms are implemented by preprocessing and postprocessing. This is a straightforward vectorization of the scalar FFTPACK with symmetric scaling incorporated into the forward and backward transforms.
The routines contained in VFFTPK include:

VRFFTI, an initialization routine for VRFFTF and VRFFTB;

VRFFTF, forward transform for multiple real periodic sequences;

VRFFTB, backward transform for multiple real periodic sequences;

VSINTI, an initialization routine for VSINT;

VSINT, forward or backward transform for multiple odd sequences;

VCOSTI, an initialization routine for VCOST;

VCOST, forward or backward transform for multiple even sequences;

VSINQI, an initialization routine for VSINQF and VSINQB;

VSINQF, forward transform of multiple odd sequences with only odd wave numbers, i.e. a quarter-wave sine transform;

VSINQB, backward transform of multiple odd sequences with only odd wave numbers;

VCOSQI, an initialization routine for VCOSQF and VCOSQB;

VCOSQF, forward transform of multiple even sequences with only odd wave numbers, i.e. a quarter-wave cosine transform; and

VCOSQB, backward transform of multiple even sequences with only odd wave numbers.

A source code distribution of VFFTPK is available. It is written in Fortran 77 and documented in an ASCII file as well as in comments in the source code itself. This is part of CMLIB.
[http://www.netlib.org/vfftpack/]
VFleet: A volume renderer for producing color images from 3-D datasets. VFleet is capable of parallel rendering via the use of the PVM library. Source code and binary distributions are available.
[http://www.psc.edu/Packages/VFleet_Home/]
vf90: A freely available Fortran 90 compiler that supports Fortran 95 syntax and optimized array syntax.
[http://www.psrv.com/lnxf90.html]
VFNLIB: A suite of Fortran programs for the evaluation of Bessel functions and modified Bessel functions or orders zero and one for a vector of real arguments. These routines are portable across a wide range of machines and vectorized in the case where multiple function evaluations are to be performed. Single and double precision versions of each routine are included.
A source code distribution of VFNLIB is available. It is written in Fortran and uses the routines i1mach, r1mach, and d1mach from the PORT library for portability. Test programs are included in the distribution. A PostScript version of Boisvert and Saunders (1992) is included in the distribution as documentation. This is TOMS algorithm 713 and is documented in Boisvert and Saunders (1992).
[http://www.netlib.org/vfnlib/]
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
VFU: The Vladi File manager for UNIX is a small and easy to use file manager. The features include:

console and text modes;

copying/moving/erasing groups of and single files;

many fast one-key commands;

filename completion;

a powerful change directory function with history and preset favorite directories;

automatic directory size calculation;

extensive user-defined external support;

user-defined file-type colorization;

incremental search and masking in all file lists; and

support for many archiving formats.

A source code distribution is available.
[http://www.biscom.net/~cade/vfu/]
VGB: Virtual GameBoy is a portable emulator of the Nintendo GameBoy video game console written in C. Binary versions are available for several machines including Linux Intel.
[http://www.komkon.org/fms/VGB/]
vgetty: A package that allows a voice modem to become an answering machine by adding voice capabilities to mgetty.
[http://alpha.greenie.net/vgetty/]
vhclmaps: A combination of the ivmaps and vhclserv packages, more about which later. This is a package of map viewers and spatial data servers that work with various map databases.
[http://www.vectaport.com/vhclmaps/]
VHDL: The VHSIC Hardware Description Language is a general purpose programming language optimized and used for the simulation and synthesis of complex digital electronic circuits. VHDL was developed in the early 1980s as part of a Very High-Speed Integrated Circuit (VHSIC) research project funded by the U.S. DOD. The development was motivated by the tasks of describing circuits of huge scale and managing large circuit design problems involving multiple teams of engineers using only the gate-level design tools available at the time.
IBM, TI and Intermetrics were contracted by the DOD to complete the specification and implementation of a language-based design description method, with the first publicly available version being VHDL 7.2 in 1985. This was eventually standardized as IEEE Standard 1076-1987 in 1987. This was supplemented by IEEE 1164 - a standard logic package that further codified some overly abstract features of 1076-1987 - to form the complete VHDL standard in widest use today. A further standard called VITAL (VHDL Initiative Toward ASIC Libraries) is currently in the works to enhance the abilities of VHDL to model timing in ASIC and PPGA design environments. A competitor to VHDL is Verilog HDL, which differs from the former chiefly in having a larger range of available simulation models and a programming language interface (PLI) that allows programs to be written in other languages and combined with Verilog.
VHDL-related programs include:

asimut, a VHDL logic simulator available as part of the ALLIANCE package;

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

CV, a toolset for verifying VHDL descriptions using a formal technique called symbolic mode checking;

CynLib, a hardware description library with capabilities for translation into VHDL;

Electric, an electrical CAD system whose capabilities include VHDL compilation;

FreeHDL, a project to create an Open Source VHDL simulator;

INSPIRE, a VHDL simulation environment;

SAVANT, a project to build an intermediate form for VHDL;

TyVIS, a VHDL simulation kernel;

VAUL, a VHDL front-end for parsing and analyzing arbitrary VHDL code;

VDT, a toolkit for the development and integration of VHDL application tools;

VHDL-GUI, a graphical tool for dealing with hierarchical block diagrams and producing the corresponding structural VHDL code.

[http://www.optimagic.com/tutorials.html]
VHDL-GUI: A graphical tool for capturing, drawing, editing and navigating hierarchical block diagrams and for producing the corresponding structural VHDL code. This can be used to create arbitrarily complex multi-level diagrams and output WYSIWYG hardcopy. It produces IEEE-1076 standard VHDL code that can be used with any VHDL compiler or simulator tools. Binary distributions are available for several platforms, with the Linux version requiring a recent version of the Lesstif library.
[http://www.atl.external.lmco.com/rassp/vgui/]
VSH3: A vectorized package of Fortran 77 subroutines for the solution of a 3-D Helmholtz equation on a staggered grid. VHS3 solves the standard seven-point finite difference (FD) approximation on a staggered grid in Cartesian coordinates with a variety of possible boundary conditions. The package consists of four routines:

HS3CRI, an initialization routine for HS3CRT;

HS3CRT, which generates a finite difference approximation on a staggered grid and solves it by calling PSTG3D;

PSTG3I, an initialization routine for PSTG3D; and

PSTG3D, which solves certain block tridiagonal systems of linear algebraic equations arising from the discretization of the 3-D Helmholtz equation on a staggered grid.

A source code distribution of VHS3 is available. All the routines are written in Fortran 77 and are documented via comment statements contained within each source code file. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
vi: A standard full-screen text editor found on most UNIX systems. Editors which emulate vi include

elvis,

nvi,

vile,

vim, and

xvi.

There is also a vi emulation mode in Emacs. See Abrahams and Larson (1996), Hewlett-Packard (1990), and Lamb (1990).
[http://www.cs.vu.nl/~tmgil/vi.html]
VIA: The Virtual Interface Architecture specification defines a standard architecture for communication within clusters of servers and workstations. VIA standardizes the interface for high performance network technologies known as System Area Networks (SANs). VIA uses a SAN to transform a collection of independent standards-based servers into a highly scalable cluster. The fast server-to-server communications can increase an applications scalability and performance, e.g. by allowing a single application to run across dozens of clustered nodes or by speeding up the exchange of data between distributed application modules.
The VIA API gives user level processes direct but protected access to network interface cards which allows applications to bypass IP processing and system call overheads while still preventing one process from accidentally or maliciously tampering with or reading data being used by another. It consists of a user-level library, kernel code that sets up protected connections, and the network interface card.
[http://www.viarch.org/]

M-VIA

An implementation of VIA for Linux platforms. It consists of a loadable kernel module and a user level library, and additionally requires a modified device driver also available as a loadable kernel module. The current (11/98) beta release supports loopback, DEC Tulip-based fast Ethernet cards, and PacketEngines GNIC-1 gigabit Ethernet card.
[http://www.nersc.gov/research/FTG/via/]
vic: A real-time, multimedia application for video conferencing over the Internet. Vic was designed with a flexible and extensible architecture to support heterogeneous environments and configurations, i.e. it can handle either high or low bandwidth situations. Vic is based on the RTP Draft Internet Standard where RTP is an application-level protocol implemented entirely within vic, i.e. no special system enhancements are needed to run it. Vic can be run point-to-point using standard IP address but should be used on a system which supports IP Multicast, ideally connected to the MBone. It supports only the video portion of a multimedia conference with vat supporting the audio, wb the whiteboard, and sd the session announcement tasks.
The features of vic include:

an Intra-H.261 video encoder,

several dithering algorithms for representing continuous-tone color video streams on color-mapped displays,

voice-switched viewing windows,

interactive title generation, and

the routing of decoded video to external video ports.

The vic system can be obtained in binary format for HP-UX, SGI IRIX, DEC OSF and Ultrix, and Sun Solaris and SunOS. The source code is also available and is supported on several additional systems including Linux Intel (using the Connectix QuickCam and the IBM PCMCIA Smart Capture Card). The Tcl/Tk package is required for compilation from source.
[http://www-nrg.ee.lbl.gov/vic/vic.html]
VIC: The Virtualized C Macros constitute a package which has been specifically designed to describe CFD algorithms in data parallel fashion. The package currently consists of ANSI C with embedded UNIX m4 and CPP macro calls that allow a source program to be translated to serial ANSI C, vectorized C, C*, MasPar's MPL/C or PVM/C. The source program is free from many of the typical dependencies on the target architecture. The package achieves efficiency by separating the computation parts from the communication parts and by grouping individual data transfers into large messages. The VIC project is currently (5/97) being extended by implementing a YACC-based translator for the C language extensions. This will add more capabilities to the macro package and also provide a more user friendly interface by detecting and reporting possible syntax and semantic errors. A sample application is available as is a technical report in PostScript which explains the project in more detail.
[http://sdcd.gsfc.nasa.gov/ESS/exchange/contrib/mobarry/vic.html]
VICE: The VersatIle Commodore Emulator is a program that can run programs written for 8-bit Commodore machines on UNIX machines. VICE can run programs written for the Commodore C64, VIC20, and PET3032-8032 machines. The emulators run as separate programs but share the same user interface and settings and support the same file formats. It provides a complete Commodore 8-bit system with all peripherals emulated, and advanced program development tools are included for easy conversion and maintenance of different file formats, both native and emulator specific.
A source code distribution of VICE is available as well as binaries for Linux (a.out and ELF) platforms. It is written in ANSI C and can be compiled on several flavors of UNIX. It is documented in a user's manual available in HTML and PostScript format.
[http://www.tu-chemnitz.de/~fachat/vice/vice.html]
[http://sunsite.unc.edu/pub/Linux/system/emulators/commodore/]
Video4Linux: A project to provide a common API to video sources, tuning sources, teletext and other TV-related VBI data. Applications that use Video4Linux include:

bttv, a Linux driver for BT848-based frame grabbers;

bttvgrab, for grabbing video sequences;

fmtools, programs for use with supported radio cards;

GRadio, for interfacing with supported radio cards;

kWinTV, a TV application for KDE;

Vstream, a video capture and editing utility;

xawtv, a suite of applications including an X11 applications for watching TV;

XtTV, a video/TV application controlled via the keyboard;

XVidCap, a video capturing program.

[http://roadrunner.swansea.uk.linux.org/v4l.shtml]
[http://www.exploits.org/v4l/]
[http://www.cse.ogi.edu/~omega/v4l2/]
[http://millennium.diads.com/bdirks/v4l2.htm]
Video for Linux Two: A rewriting of the Video4Linux API to make it more flexible and extensible as well as to support more kinds of devices. V4L2 is a suite of related driver specifications for different types of video devices and video-related data. The device types that are currently or planned to be supported include:

/dev/video, a video capture interface;

/dev/vfx, a video effects interface;

/dev/codec, a video codec interface;

/dev/vout, a video output interface;

/dev/radio, an interface for AM/FM radio devices;

/dev/vtx, a Teletext chip interface; and

/dev/vbi, a data services interface.

V4L2 specifies a set of video device APIs and defines a driver layer wrapping individual hardware-dependent video driver modules. An additional library called libv4l2 is also being developed at the user space level. It hides implementation details and adds new features not available at the kernel space level. The features will include:

hiding irrelevant implementation details, e.g. replacing the ioctl() interface with an API more suitable for a high-level language;

providing helper functions and a system-wide configuration file for basic operations, e.g. translating between RF channel numbers and the carrier frequencies required by the driver;

leveling driver capabilities, i.e. attempting to hide driver disabilities from applications (e.g. handling image format incompatibilities by providing intrinsic format conversion);

providing an environment for user space driver modules that allows applications to access them in a transparent way; and

a wrapping layer for OSS drivers for combining video and audio hardware.

[http://millennium.diads.com/bdirks/v4l2.htm]
Viewit: Multidimensional image processing software originally developed for handling data from magnetic resonance imaging (MRI), although it has much wider application. Viewit is a multidimensional array calculator and viewer consisting of 200-300 commands which perform basic array manipulation, computation, and visualization tasks. In the UNIX spirit each command performs a small tasks, with complicated tasks performed by combining several commands in a script file. All commands operate on a data stack containing all of the data.
The functions and commands of Viewit include:

stack information and manipulation functions;

data import/export and array manipulation functions (e.g. resizing, thresholding, scaling, dimension reordering, subarray removal and replacement, dimensional reduction, etc.);

sorting and indexing array elements;

calculating general data register content statistics;

matrix operations (e.g. multiplication and eigenvalue decomposition);

multidimensinal Fourier transform functions;

filters and windows;

phase correction functions;

multidimensional convolution functions;

multidimensional back-projection applications; and

various rendering and visualization capabilities.

A source code distribution of Viewit is available as are binaries for various platforms including Linux Intel. Other software needed to use Viewit includes Tcl and HDF. It is documented in separate user's and reference guides, both available in PostScript format. Various additional documentation is also available. See also the related V package.
[http://kepler.ncsa.uiuc.edu:6666/viewit.html]
Viewkit: A C++ class library for developing Motif applications. It provides a level of abstraction above that of widgets (called components) which is encapsulated in a C++ class. This follows the API of the Iris ViewKit put out by SGI and is a superset of the Iris ViewKit. Therefore any code developed for the Iris version should work with the Hungry version. There is as yet (3/96) no documentation for this, although the SGI documentation for ViewKit should suffice.
[http://www.hungry.com/products/viewkit/]
ViewML: Viewable Markup Language is an open source web browser targeted specifically at the embedded Linux platform, with the browser and its interface requiring 2 Mb of RAM with a disk image footprint of 760 Kb. ViewML was created using the KDE kfm HTML display engine, a thin glue layer, and the FLTK GUI toolkit. It under either Microwindows or X11.
[http://www.viewml.com/]
Viewmol: A graphical front-end for visualizing the output of various quantum chemical and molecular modeling programs. The capabilities of Viewmol include:

showing the geometry of a molecule;

tracing a geometry optimization or an MD trajectory;

animating the normal vibrations of a molecule or showing them as arrows;

drawing the IR, Raman, and inelastic neutron scattering spectra of a molecule;

drawing an MO energy level or density of states diagram;

illustrating the basis functions, molecular orbitals, and electron densities of a molecule; and

showing the forces acting on each atom for a given configuration.

It has input filters for the output of Discover, DMol, Gaussian 9K, Gulp, and Turbomole output as well as for PDB files. All of the drawings created can be saved as TIFF, HPGL or PostScript files, and animations of normal modes can be converted to MPEG.
A source code distribution of Viewmol is available. It can be compiled and used with either Mesa or OpenGL on most UNIX platforms. Binaries are also available for several platforms including Linux Intel. Its use is documented in a manual included in PostScript and HTML formats.
[ftp://ftp.osc.edu/pub/chemistry/software/SOURCES/C/viewmol/]
[ftp://ftp.ask.uni-karlsruhe.de/pub/education/chemistry/]
VIEW3DS: A 3D Studio file converter that can render 3D Studio models in real time using OpenGL. It can also convert 3D Studio models into either OpenGL display lists that can be used in OpenGL programs or into a BMF file. With VIEW3DS you can preview a 3D Studio file and fly around in it to see if the OpenGL translation looks good.
The features of VIEW3DS include:

triangle strip detection for model optimization;

smooth, weighted, per-vertex normal generation;

preservation of edges by rejecting polygons greater than a threshold angle;

a pop-up menu accessible through the left mouse button;

a timer to roughly measure frames per second;

information on the number of polygons, vertices and normals;

a colored starfield for a background to ease moving around; and

support for the alpha channel in 3DS materials.

A source code distribution of VIEW3DS is available. Compilation and use requires the freely available Mesa OpenGL implementation and the STRIPE package. Documentation is available onsite.
[http://www.cyberramp.net/~fdavid/]
Vigie: VIsualisation General Interactive d'Ecoulements is a package developed for the visualization of the results of hypersonic flow and magnetic field simulations. It has powerful tools for the visualization of numerical results in 1-, 2- and 3-D. 1-D plots can be viewed in both cartesian and polar coordinates. The 2-D capabilities of Vigie include:

zooming;

visualizing meshes;

visualizing isovalues or isolines,

creating and modifying colormaps,

visualizing streamlines and vectors, and

creating cross-sections of variable fields.

The 3-D capabilities include:

various types of plane cuts;

visualizing isosurfaces;

computing flow lines and surfaces;

visualizing vector fields;

volume rendering; and

animation.

All visualizations can be dumped to PostScript files.
Binary versions of Vigie are available for Sun Solaris, SGI IRIX, DEC Alpha OSF, Linux Intel and HP-UX platforms. A user's and reference manual is available in HTML and PostScript formats.
[http://www.inria.fr/sinus/Softs/vigie.html]
vile: The VI-Like Emacs editor is mostly compatible with the vi editor in terms of ``finger feel''. It also has extended capabilities including multi-file editing and viewing, key rebinding, mouse support, infinite undo, additional operator commands, selection highlighting, rectangular operations, and much more. The X11 version xvile is included as an option in the source code package and offers scrollbars and more complete mouse integration. The source code should compile and run on standard X11/UNIX platforms like Linux.
[ftp://id.wing.net/pub/pgf/vile/]
VIM: The Vi IMproved editor is a vi-compatible editor which includes almost all of the standard vi commands as well as many new ones. All of the commands can be invoked from the keyboard although there is also mouse support and a GUI version with scrollbars and menus. The improvements over vi include:

a multi-level undo whose levels can be set,

the availability of multiple windows and buffers,

the capability of recording a sequence of typed characters and repeating them any number of times,

a flexible insert mode which allows the use of the arrow keys to move around in the file,

a visual mode in which operations can be performed on sections of highlighted text,

block operators which allow the selection and highlighting of rectangular blocks of text as well as the execution of operations on them,

an online help system displayed in a separate window,

command-line editing, history and completion;,

horizontal scrolling with or without the GUI,

text formatting without the use of external programs,

compiling from within VIM and automatically jumping to the location of errors in the source code,

improved indenting for C programs,

searching for words in include files,

word completion in insert mode,

automatic execution of commands when reading or writing a file,

and a GUI which can use either the Motif or Xaw widget set.

A source code distribution of VIM is available as are binaries for several systems. The source can be compiled on most UNIX flavors as well as on DOS, OS/2, Atari, Amiga, and Windows NT/95. Binary versions are additionally available for Mac, VMS, OS/2, Win32, and Linux platforms.
[http://www.vim.org/]
[http://sunsite.unc.edu/pub/Linux/apps/editors/vi/]
ViNE: The Virtual Notebook Environment is a platform-independent, web-based interface to powerful external tool control, experiment execution, and data retrieval, storage and manipulation capabilities. The web-based interface combines the metaphor of a traditional lab book with the versatility of hypertext to create an extensible, interactive, and collaborative environment capable of supporting emerging technologies such as data mining. The ViNE architecture consists of one or more nodes called leaves distributed across the set of computer systems comprising the computational environment. The leaves can be configured and located in any desired way and together define the notebook environment. The leaves are connected by stems providing inter-leaf communication with each stem having a local server and library of communication methods. Each leaf contains a web server, a stem, a set of notebooks, and one or more functional components.
The functional components include:

a notebook browsing component that displays notebooks in a series of formatted, easily browsed pages constructed from elements described in the data organization and notebook administration components;

a notebook administration component that provides users with a set of controls for managing notebook structure (e.g. additional and deletion, page organization, and page layout) and security parameters;

a data organization component that gives notebooks the ability to reference data throughout the ViNE system;

a tool organization component used to describe and name tools available within the computational environment; and

an experiment control component providing a powerful method for combining data, tools and distributed computing resources to perform a variety of analysis tasks.

The last component is split into an experiment builder and execution controller, with the former providing an abstract visual interface for constructing experiment processes and the latter acting as a central hub for experiment operations, i.e. handling data data and tool synchronization, error control, and output management.
A source code distribution of ViNE is available. It is written using Perl and Java and achieves its web functionality via CGI scripts. Documentation includes a technical report as well as substantial online help.
[http://www.csi.uoregon.edu/vine/]
virt: A program that uses flex to produce a C source code file containing functions to emulate any terminal described in the termcap database. It processes a termcap entry into a specification that flex can use to produce a lexer, which simple executes small sections of C code whenever patterns are matched. The code that performs screen updating makes heavy use of ncurses.
[http://www.dallasnw.quik.com/slsmith/virt/]
Virtual Paper: A DEC project whose goal is to make on-line reading an attractive alternative to reading printed documents. The features of this software include:

quick performance that gets a page on the screen in significantly less than a second;

improved legibility that takes advantage of a screen's gray-scale capabilities to position characters at a finer grain than screen resolution and make characters appear less jagged;

a smooth and natural interface whose common operations can, in addition to being driven with a mouse, be performed with single keystrokes;

the capability of converting both scanned images and PostScript documents into the native Lectern format; and

various indexing and searching capabilities.

The programs comprising the package are:

Lectern, a document viewer with the features listed above;

LecternClient, a program that sends requests to Lectern;

BuildLectern, a program that constructs Lectern documents from some combination of image, PostScript and pre-existing Lectern documents;

EditLectern, which provides a graphical interface for editing the attributes of a Lectern-format document; and

LecternToHTML, which generates HTML code that describes a repository of Lectern documents.

The Virtual Paper software is written in Modula-3 and is available in either source code form or as pre-built binaries for several platforms, e.g. Digital UNIX, FreeBSD, HP-UX, IBM AIX, Linux ELF, NeXT, SGI IRIX, and Sun SunOS and Solaris. The documentation is contained within man pages for each program.
[http://www.research.digital.com/SRC/virtualpaper/home.html]
Virtual Server Project: A project to build a virtual server for Linux, i.e. a scalable and highly available server built on a cluster of real servers. The architecture of the cluster is transparent to end users who see only a single virtual server. The front-end to the real servers is a load balancer that schedules requests to the different servers and causes parallel services to appear as a virtual service at a single IP address. Scalability is provided by transparently adding or removing cluster nodes, and high availability by detecting node or daemon failures and appropriately reconfiguring the system. The high availability is maintained with the help of other packages including Heart, mon and fake.
[http://www.linuxvirtualserver.org/]
Virtual 2600: An emulator of the Atari 2600 game console that runs on UNIX/X11, SVGALib, and DOS. The features include sound support, .c26 support, PC joystick support, bank switching support, paddle emulation, and dynamic resizing under X11.
[http://www.bpwl.com/ar/emulator/2600/virt2600.htm]
VIS: The Verification Interacting with Synthesis package is a system for the formal verification, synthesis, and simulation of finite state systems. VIS uses such methods as language containment and temporal logic model checking to verify the properties of finite state systems that it synthesizes as collections of interacting finite state machines. The salient features of VIS include:

the simulation of logic circuits,

a formal implementation verification of combinational and sequential circuits,

state of the art formal design verification using fair CTL model checking and language emptiness,

logic synthesis via hierarchy restructuring and a path to and from SIS, and

a Verilog HDL front-end that compiles a subset of Verilog into an intermediate format.

Each feature can be interactively executed from any point in the design hierarchy.
A source code distribution of VIS is available as are binaries for several platforms including Linux Intel. The documentation includes a user's manual in PostScript format.
[http://www-cad.eecs.berkeley.edu/Respep/Research/Vis/]
VisAD: A Java class library for the interactive and collaborative visualization and analysis of numerical data. The features include:

the use of pure Java for platform independence and for supporting data sharing and real-time collaboration;

a general mathematical data model that can be adapted to nearly any numerical data;

a general display model that supports interactive 3-D, data fusion, multiple data views, direct manipulation, collaboration, and virtual reality;

data analysis and computation integrated with visualization to support computational steering and other complex interaction modes;

support for both developers creating domain-specific systems based on VisAD and users of these systems; and

maximum developer extensibility.

This requires at least JDK 1.2beta4 which, although currently (8/98) unavailable for Linux platforms, is being actively worked on.
[http://www.ssec.wisc.edu/~billh/visad.html]
VisDB: A visual data mining and database exploration system developed to support the exploration of large databases. VisDB implements several visual data mining techniques including:

pixel-oriented techniques, e.g. spiral, axes, and grouping techniques;

parallel coordinates; and

stick figures.

A binary distribution is available for Linux platforms.
[http://www.dbs.informatik.uni-muenchen.de/dbs/projekt/visdb/visdb.html]
Vis5D: A software system for visualizing output from numerical weather models and similar sources. It works on data in a 5-D format, i.e. three space dimensions, a time dimension, and a dimension for enumerating multiple physical variables. With this package one can create isosurfaces, contour line slices, colored slices, etc. of data in a 3-D grid and then rotate and/or animate the image in real time. The Vis5D system includes the vis5d visualization program, several programs for managing and analyzing 5-D data grids, and some other ancillary programs and examples.
The vis5d program reads data in two file formats, both of which (one old and one new) store data in a compressed format that vis5d can access quickly and efficiently. The formats are also unique to Vis5D so outside data must be converted, a task which is somewhat eased by several example conversion programs supplied with the package. Several map projections (e.g. rectilinear, Lambert conformal, stereographic, etc.) and vertical coordinate systems (e.g. equally spaced or unequally spaced in generic units or kilometers) are supported. Features of the visualization program include:

rotating, zooming, and panning the graphics;

creating and displaying wind trajectories;

creating and repositioning horizontal and vertical slices;

creating and editing text labels;

inspection of individual grid values via cursor movement;

creation of animations;

creating 3-D contour surfaces (isosurfaces) showing the 3-D volume bounded by a particular isovalue;

2-D contour plots; and

wind vector plots.

Vis5D works with SGI, IBM RS600, DEC Alpha, Stellar/Stardent, Sun, HP, DEC Ultrix, and Linux systems. It is recommended (and pragmatically necessary) that at least 32 MB of RAM are available. The 3-D rendering is performed by hardware when it is available and (more slowly) by software (using the Mesa library) when not. The documentation is contained within a 100+ Kb README file (in either ASCII or PostScript format).
[http://www.ssec.wisc.edu/~billh/vis5d.html]
[http://sunsite.unc.edu/pub/Linux/science/visualization/]
Vision-8: A portable emulator for the CHIP-8 game system which includes drivers for UNIX/X, MS-DOS, Amiga, Coleco ADAM, and MSX-1. The UNIX/X version will run in 8, 16, or 32 bits per pixel mode. A source code distribution is available.
[http://www.komkon.org/~dekogel/vision8.html]
ViSta: The Visual Statistics System is designed for students and teachers in introductory and multivariate statistics and for both neophyte researchers who want to perform statistical analyses and veteran researchers doing research and development in visual and computational statistics. It features state-of-the-art visualization techniques to guide novice data analysts, to portray the overall structure of a data analysis session, to communicate the results of analyses, and to re-estimate model parameters.
The data analysis environment has several levels to guide users from novices to experts. These include guidemaps to guide novice data analysts through complete data analyses, workmaps to allow the visual creation of data analyses and show the structure of analysis sessions, a command line interface to bypass the visual aids when they're not needed, guidance tools to let expert data analysts create guidemaps, scripts for non-interactive analyses, and the Lisp language (with access to C and Fortran) that allows the extension of ViSta. Thus one can do anything from naively viewing data to extending the system as one's data analysis skills increase.
ViSta also makes available three kinds of statistical visualization tools:

linked plots, a set of tools used to present data structure and the results of analyses;

spreadplots, tools used to explore the structure of high-dimensional data and of models of such data; and

statistical re-vision, tools used to help search for meaningful and parsimonious model parameterizations.

The first category are called empirically linked plots since they are linked via the data. These would include (in the case of table data) such plots as quantile, quantile-quantile, and scatter plots. The spreadplots - graphical equivalents of spreadsheets - are algebraically linked by equations. Groups of these might include scatterplots, spinplots, and histograms. The statistical re-vision tools allow the user to visually explore the nature of alternative parameterizations of a data analysis model.
Various extensions to ViSta called procedures are either currently available or in the planning stages. They are all included with the distribution. Currently (7/96) available are ViSta-Regress, a procedure for performing univariate multiple and simple regression and ViSta-Corresp, a procedure for performing simple correspondence analysis.
ViSta is built on top of the XLispStat package and is written in the XLisp dialect of Lisp that forms the basis of that package. It is invoked as a XLispStat program so it should work on any platform to which XLispStat has been ported. It ran on the first try on my Linux box on which I already had XLispStat (which, by the way, was easy to install as well). The documentation is contained within an 80+ page user's manual/tutorial (still being developed at this writing) in either PostScript or PDF format.
[http://forrest.psych.unc.edu/research/
ViSta.html]
VISTA: A computer graphics and vision environment requiring the Motif widget set. It allows easy extension to data types other than images and is designed to support computer vision research while allowing any user to easily program new modules or add new data types. It includes software for manipulating images, detecting and linking edges, estimating optical flow and camera calibration parameters, viewing images and edge vectors under X Windows, printing images and edge vectors on PostScript printers, and extensive documentation.
VISTA contains various image manipulation programs for scaling, cropping and rotating, adjusting image brightness, image conversion, performing arithmetical or logical operations, convolving images, computing statistics, and more. There is also a collection of interactive programs for manipulating images. There are implementations of standard vision algorithms including Canny's edge detector, algorithms for approximating edges by straight lines, the optical flow estimation procedure of Lucas and Kanade, and the camera calibration procedure of Tsai. There are C libraries containing routines for performing all of the above as well as for reading and writing files, reporting errors, parsing command line options, etc. A widget for displaying images under the X Window System is included which has built-in support for color allocation and dithering and user controls for panning and zooming the image. The is also a package which simplifies the task of building X Window applications for displaying images and accepting user input through menus and dialog boxes which shields the user from the details of widget sets and the low level X libraries. It uses the Motif widget set but can be easily ported to others.
A source code distribution of VISTA is available. It is written in ANSI C and requires at least X11R5 and Motif for installation and use. It is possible to build and use large parts of the library without Motif, however. It can be built on most UNIX flavors via the supplied imake scripts.
[ftp://ftp.cs.ubc.ca/pub/local/vista/]
Visual Cron: A GUI to cron written using Tcl/Tk 8.0.
[http://www.linux-kheops.com/pub/vcron/vcronGB.html]
Visual DHTML: A Dynamic HTML (DHTML) visual development tool written in DHTML. This runs in Netscape Navigator and allows the creation of DHTML-based content without writing code. This requires JavaScript 1.2.
[http://developer.netscape.com/docs/examples/dynhtml/visual/index.html]
Vivace: A music editor which allows you to create, edit, typeset, and generate music. A source code distribution of Vivace is available. It is known to run on Linux platforms and requires the Tcl/Tk package.
[http://www.calband.berkeley.edu/~gmeeker/vivace/]
Viz: An interactive data visualization tool for displaying large voxel-based data sets. Viz was developed to use the potential of hardware accelerated 3-D textures. The features of Viz include:

a simple and intuitive user interface;

handling very large voxel sets;

cutting through a data set with an arbitrarily positioned plane;

rotating and viewing volumes from any angle;

zoom in and out and fly-through capabilities;

shading and coloring specific data values to highlight or suppress data set features;

selecting a subset of the data for viewing;

real-time 3-D linear interpolation;

combining voxel data and geometry;

viewing two voxel sets together in a common volume;

ced, a colormap editor and browser;

MCube, a program that generates isosurfaces from voxel data;

Python and Tcl support libraries;

support for Viz native format and HDF datasets; and

C, C++ and Fortran interfaces.

A source code distribution of Viz is freely available. Compilation requires an OpenGL compliant library as well as either Coin or Open Inventor if the user desires to combined geometries and voxel data. Also required are the Qt toolkit, ILU and GLUT, with several other packages optional but needed for full functionality. Recommended hardware includes 256 Mb of RAM and hardware accelerated 3-D or 2-D texture graphics.
[ftp://ftp.ffi.no/spub/stsk/viz/index.html]
VLE: The Virtual Reality Toolkit - Lightning Eagle is a demonstration program for creating virtual reality scenarios. VLE is a set of C++ wrapper classes for the OpenGL, Mesa, and CosmoGL libraries.
[http://www.informatik.uni-bremen.de/~faust/vle.htm]
VLUGR2: An adaptive grid solver for PDEs in 2D. This solves systems of time-dependent PDEs in two space dimensions having solutions with steep gradients in space and time. The domain can be any area that can be described by right-angled polygons. It is written in Fortran 77. This is TOMS algorithm 758 and is documented in Blom et al. (1996).
[http://www.cwi.nl/%7Egollum/LUGR/VLUGR2.html]
VLUGR3: An adaptive grid solver for PDEs in 3D. This solves systems of time-dependent PDEs in 3 space dimensions having solutions with steep gradients in space and time. The domain can be any area that can be described by right-angled polyhedrons, i.e. bricks. It is written in Fortran 77. This is TOMS algorithm 759 and is documented in Blom and Verwer (1996).
[http://www.cwi.nl/%7Egollum/LUGR/VLUGR3.html]
vMac: The virtual Macintosh project aims to develop a Macintosh emulator. The goals of the project are to develop Mac hardware, provide Mac hardware emulations, provide Mac software/OS emulations in some key areas, and provide a framework for future developments in emulation. A distribution is available emulates Motorola 68000-based Mac Plus machines. A ROM image from a Plus is required for operation. Eulation of other 68000 machines such as the SE and II series is planned for future (5/98) versions. The emulator is available for several platforms including Linux Intel.
[http://leb.net/vmac/main.html]
VMailer: This has been renamed Postfix.
VMatik: A BBS package designed for large BBS systems. The features of VMatik include:

multinode approach;

a conference-based approach with a maximum of 64 conferences;

unlimited numbers of file areas, message areas and users in any conference;

32 different user access groups for customizing individual users;

configurable display modes (e.g. ANSI color, ISO-Latin, etc.);

operation as a shell;

simultaneous support for real names and nicknames;

MD5 encrypted user passwords;

numbered files that can be selected by range;

uniform file command arguments;

optional file validation;

archives that can be tested, viewed and transformed; and

background upload/download processing.

A source code distribution is available. This was developed on a Linux Intel platform and requires MySQL for many data handling chores.
[http://www.geocities.com/SiliconValley/Platform/4014/]
VMD: Visual Molecular Dynamics is a package designed for the visualization and analysis of biological systems such as proteins, nucleic acids, lipid bilayer assemblies, etc. It can also be used to view more general molecules, e.g. it can read standard Protein Data Bank (PDB) files and display the contained structure. VMD provides a variety of methods for rendering and coloring a molecule, e.g. simple points and lines, CPK spheres and cylinders, licorice bonds, backbone tubes and ribbons, cartoon drawings, and more. It can also be used to animate and analyze the trajectory of a molecular dynamics (MD) simulation, in particular it can act as a graphical front end for an external MD program and display computations occurring on another computer.
The features of VMD include:

no limit on the number of molecules, atoms, residues, or number of animation frames (other than the available memory);

several molecular rendering and coloring methods;

stereo display capability;

an extensive atom selection syntax for choosing subsets of atoms for display;

integration with the Babel program which allows it to read many molecular data file formats (although it can read PDB, CHARMM- and X-PLOR compatible binary DCD files and X-PLOR compatible PSF files without Babel);

writing the current image to a file which can then be processed by any of a number of raytracing and image rendering packages;xi

extensive graphical and text-based user interfaces created using the Tcl/Tk tool package;

extensions to Tcl which enable users to write their own routines for molecular analysis;

a modular, extensible source code written using object-oriented C++ with a programmer's guide describing the code; and

integration with the NAMD program.

The full source code for VMD is available as are binary distributions for SGI IRIX, IBM AIX, and Linux Intel platforms. Documentation is available in the form of installation, user's and programmer's guide in PostScript format.
[http://www.ks.uiuc.edu/Research/vmd/]
vmehb: The VME bus Host Bridge is a Linux loadable kernel module that is a device driver giving access to VME bus spaces. This can be used for data triggering, slow control and data acquisition in experiments using VME hardware. The vmehb distribution consists of:

vmehb, the device driver;

libvme, a general scatter/gather VME access library;

libcmd, a general Terminal User Interface (TUI) library; and

vmecmd, a TUI utility for managing and accessing VME modules.

A source code distribution of vmehb is available.
[ftp://nikhefh.nikhef.nl/pub/projects/vmehb/ftp/]
VML: The Vector Markup Language is an application of the XML which defines a format for encoding vector information together with additional markup to describe how that information should be displayed and edited. VML supports the markup of vector graphic information similarly to how HTML suppports textual information. The VML content is composed of paths described with connected lines and curves, and the markup gives semantic and presentation information for the paths. It is written using the syntax of XML and uses CSS to determine the layout of the graphics.
[http://www.w3.org/TR/NOTE-VML]

Next: Vn-Vz Up: Linux Software Encyclopedia Previous: Un-Uz Contents

Manbreaker Crag 2001-03-08