Next: Ia-Im Up: Linux Software Encyclopedia Previous: Ha-Hm Contents

Hn-Hz

Last checked or modified: Mar. 9, 1999

HNMS: The Hierarchical Network Management System is a package for monitoring the status and generating traffic statistics for large, routed IP networks. It consists of several UNIX executables and configuration files and runs in user space. It is designed to run continuously on one or more machines that are preferably dedicated to the task of network adminstration. HNMS is a distributed system incorporating three types of software modules:

a server module that maintains an up-to-date model of the network and to which all other modules are connected;

I/O modules that directly monitor portions of the network via SNMP and promiscuous Ethernet monitoring, and report their findings to the server; and

user interface modules that obtain data from the server and make it available to the user.

Inter-module communication is handled by a protocol called HNMP (Hierarchical Network Management Protocol) that facilitates subscriptions and the exchange of network data among multiple machines by building on the simple, stateless client-server model used by SNMP. A source code distribution is available. This is documented in a user's manual in PostScript format. See George and Schecht (1993).
[ftp://ftp.bayarea.net/pub/vip/jude/hnms/SOURCES/]
[http://linux.sjs.com/cool_stuff/hnms.html]
Hoard: A memory allocator for shared-memory multiprocessors that combines the best features of monolithic and pure-private heaps allocators. The overall strategy used to to avoid contention by using a local heap for each processor - like private heaps - while bounding memory fragmentation by periodically returning memory to a globally accessible heap. Each processor has a distinct heap for each size class, and Hoard allocates memory from the OS in superblocks that it subdivides into blocks in the same size class to avoid external fragmentation within superblocks. Blocks larger than the chosen superblock size are managed separately from the superblocks. Large blocks freed by Hoard are immediately placed on the globally-accessible heap for reuse by any other processor. A source code distribution is available.
[http://www.cs.utexas.edu/users/emery/]
Hobbit: An optimizing Scheme to C compiler.
[ftp://ftp.cs.chalmers.se/pub/users/tammet]
HOL: An environment for interactive theorem proving in a higher-order logic whose significant feature is its high degree of programmability via the meta-language ML. HOL has been applied to uses ranging from formalizing pure mathematics to verification of industrial hardware.
There are three versions of HOL available, i.e. HOL88, HOL90 and HOL98. Each implements the same logic but offers different functionality. The oldest version is built on top of Lisp and the more recent ones on top of ML. The most recent one uses MoscowML. A really huge amount of documentation is available in DVI format. See Gordon and Melham (1993).
[http://www.cl.cam.ac.uk/Research/HVG/HOL/]
HOMPACK: A suite of Fortran 77 subroutines for solving nonlinear systems of equations by homotopy methods to solve optimization problems. There are subroutines for fixed point, zero finding, and general homotopy curve tracking problems, utilizing both dense and sparse Jacobian matrices, and implementing three different algorithms: ODE-based, normal flow, and augmented Jacobian.
It is organized in two different ways: by algorithm/problem type and by subroutine level. The three subroutine levels are: the top leveling consisting of drivers, one for each problem and algorithm type; the second level which implements the major components of the algorithms; and the thrid level which handles the numerical linear algebra and includes some BLAS routines. The algorithm types are ODE-based, normal flow, and augmented Jacobian. The problem types are: x=f(x), F(x)=0, and rho(a,lambda,x)=0.
The package consists of the source code written in Fortran 77, test programs, a data file, and an ASCII file containing a brief overview of the package and further references. See Watson (1979) and Watson et al. (1987).
[http://www.netlib.org/hompack/index.html]
HOMPACK90: A suite of Fortran 90 codes for globally convergent homotopy algorithms. This is TOMS algorithm 777 and is documented in Watson et al. (1997).
[http://www.acm.org/calgo/contents/]
Hood: A user-level threads library for multiprogrammed multiprocessors. The user-level threads of Hood are scheduled with a non-blocking implementation of the work-stealing algorithm. This enables Hood's scheduler to use processor resources with guaranteed efficiency regardless of how the kernel chooses to schedule lightweight processes or kernel-level threads onto processors.
Hood is a user-level threads library, i.e. threads are not created and scheduled by the operating system but rather by the Hood runtime system running at user level. Parallel execution is achieved by relying on kernel threads provided by the underlying OS. The Hood runtime system automatically creates a pool of subordinate Hood processes, typically one per processor. The programmer defines Hood threads, and then the runtime system automatically schedules the threads onto its pool of processes, below which the kernel schedules the processes onto processors.
The Hood library contains definitions for six C++ classes that programs use to create and synchronize threads:

HoodThread, an abstract class with a single one-parameter virtual method called run that is subclassed by thread-defining programs that supply a definition for the run method;

SimpleHoodThread, an abstract subclass of HoodThread with a single virtual method called simpleRun that takes no parameters;

HoodLock, implements a locking synchronization action;

HoodSemaphore, implements a semaphore synchronization action;

HoodSerMach, an object associating a Hood process with a serial machine; and

HoodParMach, an object associating a Hood process with a parallel machine, i.e. a virtual multiprocessor.

A source code distribution of Hood is available. It currently works on Solaris and Linux platforms, although many library calls on the latter are not safe for use within Hood threads due to problems with the Linux implementation of pthreads. Documentation includes a user's manual and several technical papers.
[http://www.cs.utexas.edu/users/hood/]
HOPDM: The Higher Order Primal-Dual Method is a subroutine library for solving large scale linear programming problems based on an implementation of the primal-dual logarithmic barrier method. This optimization package uses multiple centrality correctors whose number is chosen to be appropriate for the given problem to reduce to overall computation time. HOPDM was designed both to offer the user the capability of building his own interior point based applications and to efficiently solve large and difficult problems. HOPDM features include a sophisticated presolver routine and a fast sparsity-exploiting Cholesky decomposition.
HOPDM is written in Fortran 77 and a C verion is also available (converted from the Fortran using f2c). The documentation is contained within several technical reports available in PostScript format. See Gondzio (1995).
[http://www.maths.ed.ac.uk/~gondzio/software/hopdm.html]
HORB: The Java Object Request Broker extends Java for distributed, object oriented computing. The HORB package consists of an HORBC compiler and an ORB runtime library, both of which are written in entirely using Java and HORB which makes execution possible on a non-modified Java interpreter. The compiler also uses a non-modified java compiler (javac) as a back-end which means that HORB will operate on any system on which the Java interpreter works and that all of the Java features can be accessed from HORB programs.
The features of HORB include:

dynamic creation of remote objects which can also inherit classes;

URL-based object naming;

daemon object and remote object connection wherein an object in the Server class is registered as a daemon object on the server side to enable it it to be operated as a daemon rather than having to create it every time;

integration of references using the interface;

object passing by value and by reference;

asynchronous method calls;

Web programming using HORB Applets;

global garbage collection and persistent objects; and

security via a distributed access control list.

The source code for the HORB distribution is available. It is written in Java and HORB and requires JDK 1.0 or greater or the equivalent for installation and use. It is documented via HTML files included in the distribution as well as in some technical reports available in PostScript format.
[http://ring.etl.go.jp/openlab/horb/]
Horizon: A image data browser which is a Java package containing a variety of tools for browsing and visualizing scientific data. The features of Horizon include:

basic 2-D visualization of multidimensional data;

zooming, subsetting and animation;

spreadsheet browsing and color fiddling;

progressive image transmission;

overlaying of multiple images;

support for collaborative sessions via Habanero; and

easy adaptability and extensibility.

A beta release (version 1.3) is available as of 8/98.
[http://imagelib.ncsa.uiuc.edu:90/imagelib/Horizon/]
Hoser FTPD: A lightweight FTP server that performs well on low-end hardware but also scales well on higher-end machines. This uses a heavily threaded model and was designed to take advantage of various features in the Linux kernel. A source code distribution is available.
[http://www.zabbo.net/hftpd/]
host: A nameserver query utility designed to update nslookup and dig by being more versatile and robust. The new features include:

extensive error checking;

optional verbose output and debugging info;

checking for extraneous conditions during zone listings;

checking for illegal characters in certain domain names;

verifying that some host-related domain names are canonical;

performing ttl consistency checking during zone listings;

recursive traversal of delegated zones up to a given level;

maintenance of a resource record and host count stats;

recognizing the new RR types defined by RFC 1183/1348;

basic NSAP support according to RFC 1637;

implementation of PX/GPOS RR type defined by RFC 1664/1712;

implementation of LOC RR types defined by RFC 1876;

support for draft RR types KEY/SIG/NXT/SRV;

configurable default options via an environment variable;

and many more.
A source code distribution of host is available. It is written in C and runs on almost all UNIX systems including Linux Intel. It is recommended to link it with a BIND 4.9.3 or newer resolver library. It is documented in a man page and in the code itself.
[ftp://ftp.is.co.za/networking/ip/dns/host/]
hostname: See NetTools.
HotEqn: A Java applet for viewing and displaying mathematical equations on the Web. This has the advantage, for those used to the syntax, of using LaTeX notation for coding the equations. Since the font sizes are variable, it can be used for both display and inline equations. Almost the entire capability of LaTeX mathematics typesetting is available with this applet, with only a few seldom used features missing. Some extensions are included to improve the quality of onscreen displays.
[http://www.esr.ruhr-uni-bochum.de/VCLab/software/HotEqn/HotEqn.html]
HotTEA: An implementation of the BASIC language written in Java. Version 2 of HotTEA is freely available.
[http://www.mbay.net/~cereus7/]
HPACK: A compression utility (last updated in Sept. 1993) with:

better compression than Arj, Zip, Zoo and others;

public key and conventional encryption of archives;

real authentication using digital signatures;

internationalization support; and

portable to a wide range of operating systems.

A source code distribution is available that contains a manual in PostScript format.
[http://sunsite.doc.ic.ac.uk/public/computing/archiving/compress/hpack/]
HPCCSOFT Tools: A collection of programs for performing various astrophysical simulation and data manipulation tasks developed by the NASA HPCC ESS group at the University of Washington. These tools include AFOF, DIRECT, FOF, SKID, SMOOTH, and TIPSY.
[http://www-hpcc.astro.washington.edu/tools/]
hpcdtoppm: A conversion program which converts a Photo-CD file into a PBM or PostScript file.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
HPC++: A C++ library and a set of tools for supporting a standard model for portable parallel C++ programming. The features of HPC++Lib include:

a Java-style thread class providing a way to program parallel applications on shared memory architectures;

a class and template library to support synchronization, collective parallel operations such as reduction, and remote memory references;

PSTL, a parallel implementation of STL;

a CORBA-style IDL-to-proxy generator used to support member function calls on objects located in remote address spaces;

a set of run-time systems that support operations involving remote communication, e.g. reductions, barrier synchronization, remote method calls, etc.

Other features of HPC++ include:

an HPC++ stub compiler;

a choice of run-time systems on which to run including Nexus, Globus and Tulip;

an HPC++ exception model; and

interoperability with other distributed systems, e.g. a communication bridge to Java contexts via the Java RMI.

[http://www.extreme.indiana.edu/hpc++/]

Open HPC++

A flavor of HPC++ modeled along the lines of CORBA to implement seamless communication among distributed, heterogeneous components. Open HPC++ is basically a research version of HPC++ used to try out new concepts and features before they're incorporated into the latter. The current (8/00) advanced features include:

an application level run-time protocol adaptivity mechanism;

a capabilities-based model of communication; and

a set of flexible and powerful load-balancing tools.

[http://www.cs.indiana.edu/~sdiwan/open-hpc++/]
HPF: The High Performance Fortran language is a set of extensions to the established International Standard for Fortran as established by the High Performance Fortran Forum (HPFF) (the home page of which is the given URL). The goals behind the development of HPF include:

support for data parallel programming (i.e. single-threaded, global name space, and loosely synchronous parallel computation);

portability across different architectures;

high performance on parallel computers with non-uniform memory access costs;

use of Standard Fortran (currently [3/97] Fortran 95) as a base; and

open interfaces and interoperability with other languages and other programming paradigms (e.g. MPI).

The first version of the language, HPF 1.0, was released in May 1993 and HPF 2.0 is currently being standardized.
HPF language features fall into four categories:

directives which appear as structured comments that suggest implementation strategies or assert facts about a program to the compiler;

new language features which are defined as direct extensions to Fortran syntax and interpretation (which differ from directives in that they are first-class language constructs and can directly affect the result computed by a program);

a library of computational functions which defines a standard interface to routines that have proven valuable for high performance computing (e.g. functions for mapping inquiry, bit manipulation, array reduction, array combining scatter, prefix and suffix, sorting, etc.); and

changes and restrictions to Standard Fortran, the most significant of which are those imposed on the use of sequence and storage association.

Several projects are underway to create HPF compilers which create code that will run on top of MPI and/or PVM. A list of HPF-related projects is given at the HPFF Site. The January 1998 issue of the Linux Journal contains an article on using HPF with Linux.
HPF-related projects include:

ADAPTOR, translates HPF source into Fortran 77 or 90 with embedded PVM or MPI calls;

HPFfe, an HPF front-end;

HPFlibrary, an HPF library written in Fortran 90;

ParkBench, a benchmark suite that includes an HPF benchmark;

PIPS, an extensible workbench for automatically analyzing and transforming scientific and signal processing applications; and

SHPF, a public domain HPF 2.0 compilation system.

Online documentation (i.e. tutorials, manuals, etc.) includes:

Introduction to HPF
[http://www.npac.syr.edu/users/haupt/tutorial/tutorial.html]

HPF Course (Edinburgh)
[http://www.epcc.ed.ac.uk/epcc-tec/hpf/]

HPF Course (Liverpool)
[http://www.liv.ac.uk/HPC/HPFpage.html]

HPF Tutorials (Vienna)
[http://www.vcpc.univie.ac.at/activities/tutorials/HPF/]

Designing and Building Parallel Programs
[http://www-unix.mcs.anl.gov/dbpp/]

[http://www.crpc.rice.edu/HPFF/]
HPFfe: An HPF front-end which includes full HPF 2.0 syntax (including full Fortran 90) and extensive semantic checking. It has also passed an extensive compliance test. The modules in the package are:

hpf2dep, a parser;

hpfsc, a semantic checking routine;

unparse, an unparser;

dumpdep, a utility to render intermediate representations;

xsageop, a class library adopted and extended from Sage++; and

a comprehensive test suite.

This source code for HPFFE is available as source code. It is written in Fortran and C and has been compiled and installed on IBM AIX, DEC OSF, Sun SunOS and Solaris, SGI IRIX, HP-UX, and Linux Intel platforms. It compiled on the first try on my Linux box. The documentation is thus far (4/97) painfully slim.
[http://www.npac.syr.edu/projects/pcrc/hpffe.html]
HPFlibrary: An HPF library written in Fortran 90. This library provides functions which are defined for combinations of 1- and 2-D array arguments. It has been compiled with both the DEC and NAG f90 compilers, the latter of which is available for Linux platforms.
[http://www.lpac.ac.uk/SEL-HPC/Materials/HPFlibrary/HPFlibrary.html]
hptomf: A utility which reads HPGL ASCII source files, interprets them, and converts them into either another vector-oriented format or one of several raster file formats. The parser only recognizes a small subset of the HP 7475 command subset, i.e. the absolute or relative Move or Draw commands, and won't do cicles, text output, or filled polygons. The available output formats include Metafont, PostScript, HP-PCL Level 3 format, Atari screen format, and PCX format.
[http://ftp.gwdg.de/pub/dante/support/hptomf/]
[http://www.rge.com/pub/tex/support/hptomf/]
hp2xx: A tool to convert vector-oriented graphics data given in Hewlett-Packard's HP-GL plotter language into a variety of other both vector- and raster-oriented graphics formats. The supported output formats include Encapsulated PostScript (EPS), PCX, IMG, and several formats which facilitate the generation of graphics within TeX documents. There are also utilities to send hp2xx output to HP Laserjet/Deskjet printers and to preview HP-GL on X11 and DOS platforms.
A source code version of hp2xx is available. This can be easily compiled on a variety of platforms using the GNU standard configuration and compilation tools. Its use is documented in a user's manual supplied in Texinfo format.
[http://www.gnu.org/order/ftp.html]
[http://www.gnu.org/software/hp2xx/hp2xx.html]
HPVM: The High Performance Virtual Machine is a software package which supports high performance computing on distributed resources. HPVM supports a range of supercomputing APIs and convenient cluster management, enabling supercomputer performance with a collections of PCs, the software, and a high speed network. The front-end is a Java applet and daemon which together support the convenient remote use of cluster computation resources. It can be run on any machine supporting the Java Virtual Machine.
The application programming interfaces (APIs) available with HPVM include Fast Messages (FM), a low-level messaging layer designed to deliver the performance of the underlying hardware to the application. FM is also designed to enable convenient and high performance layering of other APIs and protocols on top of it. It does this by providing such features as efficient gather/scatter, receiver rate control, and per-packet multithreading. FM is the core communication layer of the HPVM project. A higher level API is MPI-FM, a high performance cluster implementation of MPI, a standard communication interface for message-passing parallel programs which provides many capabilities including synchronous and asynchronous messaging, datatypes, and communicators. It is a complete implementation of the MPI standard 1.0 based on MPICH. Another API is Shmem Put/Get-FM, a cluster implementation of the Shmem Put/Get interface based on the Shmeme library for the Cray T3D. This library provides a shared global address space, data movement operations betweenlocations in that space, and synchronization primitives. The Global Arrays-FM API is an implementation of the Global Array interface for clusters, which supports abstractions for global arrays, data movement between them and local arrays, and synchronization across nodes. It is a complete library for writing single-program multiple-data (SPMD) programs.
Binary distributions of HPVM are available for Windows NT and Linux Intel platforms. The Linux distribution supports network interfaces to Myrinet (a gigabit-per-second LAN and SAN) as well as UNIX sockets. Documentation includes a user's manual as well as several technical reports and talks available in HTML and PostScript format.
[http://www-csag.cs.uiuc.edu/projects/hpvm.html]
HSL: The Harwell Subroutine Library is a general library of mathematical subroutines written in Fortran 77 (and also in Fortran 90). The library contains routines for computer algebra, differential equations, eigenvalues and eigenvectors, mathematical functions, geometrical problems, integer valued functions, sorting, linear programming, matrices and linear algebra, nonlinear equations, polynomial and rational functions, numerical integration, statistics, interpolation and approximation, optimization and nonlinear data fitting, and more.
The full library is available for a fee. A part of the library called the MA28 package is freely available from Netlib. This package consists of four routines for the solution of sparse linear equations where the coefficient matrix may be unsymmetric and numerical pivoting may be required for stability. Documentation for the entire library is available in PostScript format at the HSL Web site.
[http://www.dci.clrc.ac.uk/Activity.asp?HSL]
HSPF: The Hydrological Simulation Program - Fortran simulates hydrologic and associated water quality processes on pervious and impervious land surfaces, streams, and well-mixed impoundments for extended periods of time. HSPF uses continuous rainfall and other records to compute streamflow hydrographs and polllutographs. It simulates interception soil moisture, surface runoff, interflow, base flow, snowpack depth and water content, snowmelt, evapotranspiration, groundwater recharge, dissolved oxygen, biochemical oxygen demand, temperature, pesticides, conservatives, fecal coliforms, sediment detachment and transport, sediment routing by particle size, channel routing, reservoir routing, constituent routing, pH, ammonia, nitrate-nitrate, organic nitrogen, orthophosphate, organic phosphorous, phytoplankton and zooplankton.
HSPF can simulate one or many pervious or impervious unit areas discharging to one or many river reaches or reservoirs. Frequency-duration analysis can be performed for any time series, with any time-step from 1 minute to 1 day. It is generally used to assess the effects of land use change, reservoir operations, point or nonpoint source treatment alternatives, flow diversions, etc. HSPF contains hundreds of process algorithms developed from theory, laboratory experiments, and empirical relations from instrumented watersheds. The HSPEXP package is an expert system for calibrating HSPF.
A source code distribution of HSPF for UNIX platforms is available. The primary documentation is contained within Bicknell et al. (1997). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/hspf.html]
[http://www.geogr.uni-jena.de/software/hspf.html]

HSPEXP

An expert system for the calibration of HSPF which allows interactive editing of HSPF input files, simulation with HSPF, producing plots of HSPF output compared to observed values, computing error statistics for a simulation, and provides the user with expert advice on which parameters should be changed to improve the calibration. HSPEXP uses over 35 rules involving over 80 conditions to recommend parameter adjustments. The rules are divided into four phases-for annual volumes, low flows, storm flows, and seasonal flows. Rules in subsequent phases are not tested until all rules in the previous phase pass, with all rules based on the experience of experts in the use of HSPF in a wide range of climates and physiographic regions.
A source code distribution of HSPEXP for UNIX platforms is available. The primary documentation is contained within Lumb et al. (1994). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/hspexp.html]
[http://www.geogr.uni-jena.de/software/hspexp.html]
HST3D: A simulator for heat and solute transport in 3-D ground water flow systems with variable density fluids. HST3D solves a system of three governing equations coupled through the interstitial pore velocity, the dependence of the fluid density on pressure, temperature, and solute-mass fraction, and the dependence of the fluid viscosity on temperature and solute-mass fraction. The equations solved are: (1) a saturated groundwater flow equation formed from the combination of the conservation of total fluid mass and Darcy's Law for flow in porous media; (2) a heat transport equation formed from the conservation of enthalpy for a fluid and porous medium; and (3) a solute transport equation formed from the conservation of mass for a single solute species which can decay and adsorb onto the porous medium. Boundary conditions offered include specified value, specified flux, leakage, heat conduction, an approximate free surface, and two types of aquifer influence functions.
A finite-difference technique is used to discretize the governing equations using a point-distributed grid. The equations are solved in turn after a partial Gauss reduction scheme is used to modify them such that they are more tightly coupled and have better stability. Two techniques are avaiable for the solution of the resulting matrix equations: (1) a direction elimination solver using the equations reordered by alternating diagonal planes; and (2) an iterative solver using two-line successive overrelaxation. Solutions are obtained for the dependent variables pressure, temperature, and solute concentration.
A source code distribution of HST3D for UNIX platforms is available. The primary documentation is contained within Kipp Jr. (1986). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/hst3d.html]
[http://www.geogr.uni-jena.de/software/hst3d.html]
ht://Dig: A complete Web indexing and searching system for a small domain or intranet. It is meant to satisfy the search needs for a single company, campus or subsection of a Web site. It can span several servers at a site as long as they all understand the HTTP 1.0 protocol. The features of ht://Dig include:

support for the Standard for Robot Exclusion;

arbitrarily complex boolean expression searching;

configurability of search result output via HTML templates;

fuzzy searching via various configurable algorithms including exact, soundex, metaphone, common word endings and synonyms;

search of both HTML and regular text files;

email notification of expired documents;

indexing of protected servers via password and username;

searches on subsections of sites via specification of URL patterns;

limiting searches by depth; and

full support for the ISO-Latin-1 character set.

A source code distribution of ht://Dig is available under the GPL. It is written in C++ and has been compiled under Linux Intel using G++. Documentation is included in the distribution and also available on the site.
[http://htdig.sdsu.edu/]
HTDP: The Horizonal Time-Dependent Positioning program allows the prediction of horizontal displacements and/or horizontal velocities related to crustal motion in the coterminous U.S. and Alaska. It can also be used to update positional coordinates and/or geodetic observations to a user-specified date. These activities are supported for coordinates in the North American Datum of 1983 and in all official realizations of the ITRF, so HTDP can be used to transform positional coordinates between any pair of these reference frames in a way that rigorously addresses differences in the definitions of their respective velocity fields. Velocities can also be transformed between any pair of these reference frames.
HTDP uses models that address both the continuous and episodic components of crustal motion. The models assume, for continuous motion, that points on the Earth's surface move with constant horizontal velocities. Episodic motion is characterized using the equations of dislocation theory.
HTDP is written in Fortran 77. The source code is available along with a user's manual in PDF format.
[http://www.ngs.noaa.gov/TOOLS/Htdp/Htdp.html]
HTE: HTML Template Expander is a preprocessor for maintaining consistent and up-to-date Web sites. The features include:

a syntax that allows the use of most existing HTML documents;

a template facility for whole and partial HTML documents wherein HTE templates are similar to parameterized macros but with multiple inheritance among templates and default values for parameters;

variables and constants to provide short names for long parts;

features for supporting HTE template libraries and modules such as include and package files;

features that link it with the rest of the world like timestamp formatting, execution of external commands, and reading environment variables;

rigid consistency checks;

an eval statement to overcome the rigid consistency checks; and

options to remove unnecessary spaces from HTML files.

A source code distribution of HTE is available. It is written in ANSI C and thus portable to many platforms. An introduction and a full language reference are available in the way of documentation.
[http://www.uni-muenster.de/WiWi/home/rentmei/hte/]
HTeX: A preprocessor that allows equations formatted with LaTeX to be embedded into HTML documents. This processes the equations using LaTeX and then converts them into GIF files for display on the Web pages. The Perl script is available.
[http://www.gams.com/contrib/htex/htex.htm]
htgrep: A Perl utility to facilitate the construction of simple search engines for the Web as CGI scripts. Htgrep allows you to query an document accessible to your HTTP server on a paragraph by paragraph basis by providing a generic front-end to htgrep.pl, a Perl program for implementing search engines. It allows you to pass all parameters to the search package as part of the URL so a forms interface can be used to set the parameters.
The features of htgrep include:

queries which may be either boolean keyword searches or regular expressions;

support for bullet, numbered, or description lists;

you can supply your own forms interface to your search engine;

plain text can be searched with automatic recognition of URLs;

refer bibliography files can be searched and formatted on the fly;

optional case sensitivity;

footer files;

configurable record separators; and

multi-file searching.

The source code for htgrep is available. It is written in Perl and can be used on any platform with Perl and an HTTP server installed. It is documented in a man page as well as in a FAQ at its home site.
[http://www.iam.unibe.ch/~scg/Src/Doc/htgrep.html]
H.323: A protocol providing a foundation for audio, video and data communications via IP-based networks. H.323 is a recommendation by the ITU that sets standards for multimedia communications over LANs not providing a guaranteed QoS. It is part of a larger series of communications standards that enable videoconferencing across a wide range of networks. This is the protocol that will be used for the future of Internet telephony.
[http://www.pulver.com/h323/]
[http://www.databeam.com/h323/h323primer.html]

OpenH323

A project to develop an Open Source H.323 protocol stack for Linux and Win32.
[http://www.openh323.org/]
HTML: The HyperText Markup Language is defined as an SGML document type definition (DTD) containing a fixed set of data markup tags which can be used to identify many of the elements found in typical electronic documents, i.e. it is a markup language for hypertext which is used in WWW clients. HTML provides users with the ability to link from one part of a document to another or from one document to another. Major features of HTML documents include links between anchors, images and image maps, forms, applets (usually written in Java, and styles and scripts. The current (5/97) official version is HTML 3.2 which extends the HTML 2.0 standard to include tables, applets, text flow around images, superscripts, and subscripts.
Packages that help in creating HTML documents include:

Amaya, an authoring environment for the Web;

AppGen, a language and application generator for producing Web-based applications;

asWedit, an HTML editor;

bib2html, which converts BibTeX files into HTML;

Bulldozer, an HTML editor;

CHPP, a preprocessor for HTML documents;

Curl, a language for creating Web documents;

Datapult/PF, a tool for creating dynamic HTML documents;

gtml, a HTML preprocessor with features designed for maintaining multiple Web pages;

heitml, a language for creating HTML pages;

HMML, a macro language for preprocessing HTML;

HTE, a preprocessor for avoiding redundancy in HTML documents;

HTMLDOC, which generates indexed HTML, PostScript and PDF files from HTML files;

HTMLgen, a class library for the generation of HTML documents using Python;

htmlpp, a preprocessor for HTML documents;

HTML++, a textual language to create sets of HTML documents;

html2latex, converts HTML files into LaTeX files;

htp, a preprocessor for HTML;

Hyperlatex, a program to convert LaTeX into HTML;

HyperTeX, a program to convert TeX into HTML;

jamal, a macro language for HTML documents;

LaTeX2HTML, a program to convert LaTeX into HTML;

Latte, a language for creating HTML documents;

Ltoh, which converts LaTeX into HTML;

Meta-HTML, an HTML-based scripting language;

MHonArc, a Perl script for converting email messages into HTML;

PHP, an HTML scripting language;

Q-HTML, for coverting text into HTML;

QML, a language for web site development;

TeX4ht, which can convert TeX and LaTeX documents into HTML;

texi2html, which translate Texinfo documents into HTML;

troffcvt, which translates Troff source code into HTML;

tth, which translates plain TeX into HTML;

UDO, a system that can convert documents in its own UDO format into HTML;

WASP, a Java library for developing complex Web applications;

WebEQ, a Java applet for converting math into HTML;

WebMacro, a Java server-side template engine and servlet development framework;

WML, a set of preprocessors for generating HTML;

wwwtable, a Perl script for producing HTML tables; and

XHTML, an HTML editor.

Several software packages exist for checking HTML documents including:

Bobby, which helps make Web pages more accessible to those with disabilities;

Checkbot, a tool for verifying links on a set of HTML pages;

curl, a tool for automatically generating the links between parts of a Web document;

htmlchek, a tool for syntactically checking HTML files;

LCWA, a Web agent that determines the last changed times of HTML documents;

linbot, a site management tool that tracks down broken links and much more;

MOMspider, a web-roaming robot that maintains distributed hypertext information structures;

Tidy, a program for prettyprinting HTML and correct common errors in it;

weblint, a tool for checking syntax and minimal style for HTML; and

webxref, a program to check links in Web documents.

[http://www.w3.org/pub/WWW/MarkUp/]
htmlchek: A package that syntactically checks HTML 2.0 or 3.0 files for a number of possible errors, performs local link cross-reference checking, and generates a rudimentary reference-dependency map. A source code distribution is available. It is written in awk and Perl.
[http://uts.cc.utexas.edu/~churchh/htmlchek.html]
HTMLDOC: A program that generates indexed HTML, PostScript, and PDF files from HTML source code. It includes a simple GUI interface to manage the HTML files and automatically (re)generate files for viewing and printing. A source code distribution is available that requires Motif for compilation, although this is also known to work with Lesstif.
[http://www.easysw.com/htmldoc/]
HTML Document Object: A Perl module package for quickly and easily generating dynamic HTML documents without having to deal with the HTML overhead. HTML Document Object provides template objects into which content is entered. It then dynamically generates the necessary HTML code. The features include:

frames and cookies;

JavaScript and the JavaScript Error Handler;

support for OnLoad and OnUnLoad events;

meta tags;

link and base tags;

compatible with HTML 4.x; and

internationalization support.

[http://htmlobject.sourceforge.net/]
HTMLgen: A class library for the generation of HTML documents using Python scripts. HTMLgen is used to create HTML pages containing information that changes from time to time, e.g. a summary of system data collected each night or a catalog of data and images that needs to be turned into a web site. HTMLgen works by having a separate class for each HTML element type, with each class supporting a method for emitting itself as HTML text markup.
HTMLgen defines a class hierarchy supporting several types of documents. The document classes include:

BasicDocument, provides the common HTML document features for the other classes, although it isn't abstract and can be used directly;

SeriesDocument, supports a style of web page structure described in the Web Page Style Manual at the Yale Center for Advanced Instructional Media, although the specifics can be altered via parameters in a resource file;

SimpleDocument, a simpler version of SeriesDocument without the header and footer structure that is particularly useful for CGI scripts and documents where the content is fully customized;

FramesetDocument, inherits from BasicDocument and is used as a container for Frameset class objects only; and

TemplateDocument, supports the use of an initial HTML file as a template into which substitutions are made a run time.

Other useful classes include:

List, structured to allow full nesting of either regular Python data types or HTMLgen objects, as well as to allow lists to be rendered into multiple columns;

Frameset, for breaking pages into multiple panes, i.e. frames;

Table and TableLite, allowing tables to be specified in either a simple or a more flexible way;

Forms, provides full form support for using the POST method;

Map, supports both client and server side imagemaps;

Script, adds support for scripting languages.

[http://starship.python.net/crew/friedrich/HTMLgen/html/main.html]
HTML PLAIN: The HTML Precompiler Lacking An Interesting Name is just what the name says it is. The features includes:

the use of symbolic names instead of filenames to allow files to be moved around without breaking links;

templates that allow the customization of each page and fast layout changes;

user-defined tags for structuring documents;

a set of pre-defined templates;

the capability of writing Perl macros to access metadata and provide more flexibility;

automatic handling of tedious tasks such as inserting image sizes and making link lists; and

human-readable output.

A source code distribution is available under the GPL.
[http://artho.com/webtools/plain/]
htmlpp: A preprocessor for HTML documents. It acts like a compiler by taking an input source text file and producing an HTML document. Htmlpp breaks one input source text file into several HTML documents and lets you define symbols, e.g. version number, in one place that can be used anywhere as variables. It creates tables of contents and links to chain pages together in sequence. It adds headers and footers to pages so a consitent style can be maintained across many pages. It lets you define macros to simplify markup, converts plain text into HTML using what is called guru mode, and convertes accented characters into HTML meta-characters. Guru mode is a basic text-to-HTML converter which can convert the majority of a document correctly and leave the user to do some fine tuning to finish it.
A source code distribution of htmlpp is available. It is written in Perl and can use either version 4 or 5. It is documented in a user's guide available in both hard copy and HTML formats.
[http://www.eleves.ens.fr:8080/home/nthiery/htmlpp/index.html.en]
HTML++: A textual language for specifying the layout, contents and relationships between sets of Web pages and CGI scripts. HTML++ is an object-oriented language and a compiler for that language which creates HTML pages. It includes features like interdocument relation control, style definitions adoptable in pages and CGI scripts, and import of flat textual databases. A source code distribution is available. It is written in Perl and requires version 5 or greater. It is documented in a user's manual available in PostScript format.
[http://www.infosys.tuwien.ac.at/HTML++/]
html2latex: A Perl script that converts an HTML file into a LaTeX2e file.
[http://www.geom.umn.edu/software/download/html2latex.html]
html2ps: A script which converts HTML to PostScript. This is written in and thus requires Perl 5.
[http://www.tdb.uu.se/~jan/html2ps.html]
htp: An HTML pre-processor which accepts as input text files that contain a mixture of standard HTML and special mark-up tags that only htp understands. The HTML tags may be changed according to various user options that can be enabled or disable. The special htp are stripped but are used as directives and are what add functionality to htp. Features include template-based document creation, macro expansion, include files, file information, automatic image information, and more. The latest version of htp (0.14 as of 1/3/96) is available for Linux platforms.
[http://www.crl.com/~jnelson/htp/]
HTTP: The HyperText Transfer Protocol is an application-level protocol for distributed and collaborative hypermedia information systems, i.e. it is the primary protocol underlying the World Wide Web. It is a generic, object-oriented protocol which can be used for many tasks, e.g. name servers and distributed object management systems, through extension of its request methods. Systems can be built independently of the data being transferred due to the typing and negotiation of data representation in HTTP. The given URL is that of the W3 Organization's HTTP site.
An HTTP server is required to distribute information via the Web. Available servers include:

AOLserver, a server with a multithreaded architecture;

Apache, the most widely used server and descended from the original NCSA HTTPD server;

Boa, a single-tasking high performance server;

DeleGate, a multipurpose proxy server;

fhttpd, a general purpose FTP/HTTP server;

Hawkeye, a complete Internet/Intranet server suite;

HTTPd, the original NCSA server;

HTTPGate, a filtering HTTP gateway;

Jetty, an Open Source servlet server written in Java;

Jigsaw, a server written in Java;

Kirves-httpd, a small server based on libwww-perl;

Mathopd, a small server designed for large numbers of connections;

Medusa, an architecture for high performance servers written in Python;

MOWS, a distributed web and cache server written in Java;

NetForge, a server written in Java;

Nexus, a server written in Java;

phttpd, a multithreaded, lightweight and fast Web server;

Pi3Web, a full-featured HTTP server;

pWEB, a parallel Web server harness;

Roxen, a modularized and object-oriented server;

Shadow, an HTTP server written in Guile;

TclHttpd, a server written using Tcl/Tk;

thttpd, a very small, fast and secure server;

WN, a server whose design goals are security, robustness, and flexibility;

W3C httpd, a generic full-featured hypertext server which can be used as a regular HTTP server; and

Xitami, a portable multithreaded server.

Server-related software includes:

Webjamma, an artificial HTTP traffic generator for testing servers;

[http://www.w3.org/pub/WWW/Protocols/]
HTTP-NG: A project to develop an HTTP for the Next Generation to update and enhance the current HTTP standard. The project aims to design, implement and test a new protocol architecture based based on a three layer model consisting of:

a transport layer at the bottom providing connection semantics;

a request/response messaging layer using an efficient wire protocol with a lightweight type system; and

an application layer where current and future applications can be implemented.

HTTP-NG should be flexible enough to support existing uses as well as the increasing number of new applications being developed. It should also be significantly better to encourage switching from the original standard.
[http://www.w3.org/Protocols/HTTP-NG/]
HTTPd: The original NCSA HTTPd server.
[http://hoohoo.ncsa.uiuc.edu/docs/Overview.html]
HTTPGate: A filtering HTTP gateway that can be used to improve privacy while perusing the Web. It can also be used as an anti-filtering proxy proxy to avoid censoring software. The program is compiled and then the executable is run given a port number on your machine. Your Web browser is then launched with a URL associated with this port number. A page then appears in which you can enter any URL and select from a set of options that allow you to avoid transmitting selected information during a client/server negotiation. A source code distribution of the C program is available.
[http://www.ajk.tele.fi/~too/sw/HttpGate/httpgate.html]
httptunnel: A program that creates a bidirectional virtual data path tunnelled in HTTP requests. The requests can also be sent via an HTTP proxy. This could be useful for those behind restrictive firewalls. If Web access is allowed via an HTTP proxy, then this can be used to use Telnet or PPP to connect to a computer outside the firewall.
[http://www.nocrew.org/software/httptunnel.html]
HTTrack: An offline browser utility for downloading web sites from the Internet to a local directory. It builds all directories recursively, getting HTML source, images and other files from the server to the local directory. It also arranges the original site's relative link structure such that it can be browsed identically locally. Additional features include:

mirroring more than one related site (with shared links) together;

user-selectable recursion levels;

quick updates for downloaded sites;

resuming interrupted downloads;

filtering by file type, link location, structure depth, file size, site size, accepted or refused sites, or filename (with advanced wild cards);

timeout and minimum transfer rate managers;

a wizard to specify which links must be loaded;

a multiple connection mode to maximize downloading speed;

proxy support;

reget/resume for partially transferred files;

an integrated DNS cache; and

user-specifed paths for mirror and log files.

[http://httrack.free.fr/]
Hugs: The Haskell Users' Gofer System is the the successor the the Gofer project and an almost complete implementation of Haskell 1.3 including:

lazy evaluation, higher order functions, and pattern matching;

a wide range of built-in types from characters to bignums;

an advanced polymorphic type system with type and constructor class overloading;

all of the Haskell 1.3 expression and pattern matching syntax including lambda, case, conditional, and let expressions as well as list comprehensions, do-notation, operator sections, and several pattern types; and

an implementation of the main Haskell 1.3 primitives for monadic I/O with support for simple interactive programs, access to text files, and exception handling.

The module system is not supported.
Hugs is implemented as an interpreter which provides:

a relatively small and portable system which can be used on a wide variety of platforms;

a read-eval-print loop for displaying the value of each expression that is entered into the interpreter;

fast loading, type checking, and compilation of script files with facilities for the automatic loading of imported modules;

integration with a user-chosen external editor; and

modest browsing facilities.

A source code distribution of Hugs is available. It is written in ANSI C and can be compiled and used on most UNIX systems. Extensive documentation is included in the distribuiton.
[http://www.haskell.org/hugs/]
Hull: A program that computes the convex hull of a point set in general but small dimension. The input is a list of points and the output a list of the facets of the convex hull of the points, with each facet presented as a list of its vertices. The facets are assumed to be simplices such as triangles in 3-D. The program can also compute Delaunay triangulations, alpha shapes, and volumes of Voronoi regions. It uses exact arithmetic when possible which offers a moderate speed penalty, e.g. a factor of 2 or 3 for Delaunay triangulation and slightly less for convex hulls.
The Hull program is available in source code format. It is written in ANSI C and portable to many flavors of UNIX. Its use is documented in a man page.
[http://www.netlib.org/voronoi/]
HURD: The Hird of UNIX-Replacing Daemons (where Hird stands for Hurd of Interfaces Representing Ddepth) is the GNU project replacement for the UNIX kernel, Hurd is a collection of servers which run on the Mach microkernel to implement file systems, network protocols, file access control, and other features implemented by the UNIX or similar kernels. The first test release of the Hurd was on August 6, 1996.
[http://www.gnu.ai.mit.edu/software/hurd/hurd.html]
Hush: The Hyper Utility SHell is a library and interpeter offering a C++ interface to the Tcl/Tk toolkit and its extensions. This allows a programmer to employ the functionality of Tcl/Tk in a C++ program. It offers widget and graphics classes with an easy-to-use interface but allows more experience programmers to also use the Tcl scripting language to define the behavior and functionality of new widget and structured graphics objects. The design of Hush was inspired by the InterViews library, although the use of event callbacks and the functional interface of widget and graphics classes in significantly simpler. With Hush existing applications written for the Tk interpreter wish can be easily reused in a C++ context with little or no cost.
The source code for the Hush package is available. It is written in C++ and can be compiled using gcc. Hush has been tested on Sun Solaris and SunOS and Linux platforms and should be readily portable to other generic UNIX systems. An experimental Windows 95 port is also available. Several manuals and tutorials for Hush are available in HTML and PostScript format.
[http://www.cs.vu.nl/~hush/]
HUTear: A Matlab toolbox for auditory modeling. HUTear is a modular package containing a generic framework for an auditory model and a set of modules for producing models for particular applications. The structure model has five main fields where the elements of an auditory model are defined:

model.outmid, an outer and middle ear model, e.g. a fixed filter;

model.cochlea, cochlear filtering, e.g. a gammatone filterbank;

model.haircell, mechanical to neural transduction, e.g. an inner hair cell model;

model.neural, neural processing, e.g. a model for neural adaptation; and

model.pp, postprocessing, e.g. scaling or mapping to a decibel scale.

[http://www.acoustics.hut.fi/software/HUTear/]
Hv: A graphical user interface library for scientific and engineering applications. It provides for multiple views in a single window with independent world and pixel coordinate systems via more than 500 callable functions. Hv performs all needed coordinate transformations and window maintenance as well as providing applications with the ability to save their views as PostScript of Encapsulated PostScript files.
Hv is not an interface builder but rather a library whose use results in applications with a unique appearance and feature set. It is also not primarily intended to be a data visualization package since it is mostly used to display and interact with representations of physical objects (experimental rigs, geographic locations, etc.) rather than complex data sets, although it can create simple scientific graphs such as of the results of a simulation. Important features include the maintenance of a floating point world coordinate system to accomodate the real dimensions of what is being represented (e.g. a detector array in a nuclear physics laboratory), the capability of getting instant feedback about the attributes of an item by moving the pointer over that item, and a mechanism for registering multiple simulations, i.e. one application can have many simulations running simultaneously with each being updated at a different, controllable rate.
Hv requires a UNIX/X Windows platform with the Motif library (version 1.1 or greater) and a color monitor that supports 256 colors or gray scales. The source code is available and is written in ANSI C. It has been tested on several platforms including DEC (Ultrix and OSF), Sun, SGI, IBM, HP and Linux. A brief overview of Hv and a 138 page programming manual are available in PostScript format. The distribution comes with several example applications, including a scientific graphics application called hvplot.
[http://www.cebaf.gov/ccc/help/Hv/index.html]
hvplot: A scientific plotting package built using the Hv graphical user interface development library. Hvplot generates 2D plots of various types usually found in science, creates black and white or color PostScript output files or encapsulated PostScript files, provides a simple point-and-click, drag-and-drop interface, provides a library of symbols, fonts, line styles, colors, etc. for annotating and modifying graphis, provides the capability to fit data to polynomials, exponentials or sums of gaussians. It doesn't do 3-D graphics or bar or pie charts, although 3D capabilities are planned. Data cannot be edited or manipulated (other than scaling) within hvplot.
Hvplot is contained within the Hv package mentioned above. It requires a UNIX platform with X Windows and the Motif library (1.1 or later). The documentation is contained within a 27 page manual in PostScript format.
[http://www.cebaf.gov/ccc/help/Hv/hv.html]
HWM93: The Horizontal Wind Model is an empirical model of the horizontal neutral wind in the upper thermosphere. It is based on wind data obtained from satellites, with a small number of vector spherical harmonics used to described the zonal and meridional wind components. The model describes the transition from predominantly diurnal variations in the upeer thermosphere to semidiurnal variations in the lower thermosphere, and a transition from summer to winter flow abovae 140 km to winter and summer flow below. The model provides zonal and meridional winds for specified latitude, longitude, time and Ap index. See Hedin et al. (1996).
[ftp://nssdc.gsfc.nasa.gov/pub/models/atmospheric/hwm93/]
Hydra: An adaptive particle-particle, particle-mesh plus smoothed particle hydrodynamics N-body simulation program that can be used with either periodic or isolated boundary conditions. A source code distribution is available which contains a makefile set for compilation on several platforms including Linux Intel.
[http://coho.astro.uwo.ca/pub/hydra/hydra.html]
HYDROTHERM: A 3-D finite-difference model for simulating multiphase groundwater flow and heat transport in the temperature range from 0 to 1,200 degrees Celsius and the pressure range from 0.5 to 10,000 bars. HYDROTHERM solves numerical approximations to mass and energy balance equations posed in terms of pressure and enthalpy. It is assumed that the rock matrix can be treated as a porous medium, that water and rock are in thermal equilibrium, and that capillary pressure is negligible. Radial solutions in 1- and 2-D can be obtained as well as 1-, 2-, and 3-D solutions in Cartesian coordinates.
The use of pressure and enthalpy as the dependent variables in HYDROTHERM allows the unique specification of the thermodynamic state of the fluid under single- and two-phase conditions. Constitutive relations describe the required fluid properties, e.g. density and viscosity of steam and liquid, enthalpies of saturated steam and liquid. The equations are simultaneously solved in an approach wherein the nonlinear coefficients (relative permeabilities, densities, and viscosities) are treated using Newton-Raphson iteration, resulting in a system of linear equations to be solved for each iteration. The matrix is directly solved for 1- and 2-D systems and via an embedded slice-successive overrelaxation technique for 3-D systems.
A source code distribution of HST3D for UNIX platforms is available. The primary documentation is contained within Mayba and Ingebritsen (1994). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/hydrotherm.html]
[http://www.geogr.uni-jena.de/software/hydrotherm.html]
HylaFAX: A facsmilile system for UNIX platforms. It supports sending and receiving FAXes, polled retrieval of FAXes, transparent shared data use of the modem, and sending alpha-numeric pages. A FAX can be any size and can be transmitted as either 1-D or 2-D encoded FAX data. Any modem that supports one of the standard interfaces for FAX operation can be used, i.e. Class 1, 2 and 2.0 modems. The features of HylaFAX include:

automatic recognization and conversion of outgoing documents in nearly any format;

automatic cover page generation with configurable cover pages;

a text-based phonebook database;

setting up an email to FAX gateway service;

automatic email deliver or printing of incoming FAX;

monitoring of sending and receiving queues via a faxstat program;

a client-server architecture wherein FAX modems can reside on single machines on a network and clients can submit outbound jobs from any properly configured machine on the network;

an access control mechanism to control which users on which machines can access a server;

scheduling of multiple modems on a single server for high throughput;

support for broadcast FAXing via optimal imaging of transmitted documents and effective scheduling of modems; and

support for scheduling jobs during off-peak hours based on destination phone numbers.

A source code distribution is available which can be compiled and used on many UNIX flavors including Linux. The November 1997 issue of the Linux Journal contains an article about HylaFAX.
[http://www.hylafax.org]
Hyperbole: An open and programmable hypertextual information management and outliner system that runs as a subsytem of InfoDock or Emacs. Hyperbole allows hypertext buttons to be embedded within unstructured and structured files, mail messages and news articles. This allows mouse-based control of information display within multiple windows, providing point-and-click access to Info manuals, FTP archives, WAIS servers, and the Web via encapsulations of software supporting the appropriate protocols.
Hyperbole consists of four main parts:

an interactive information management interface including a powerful rolodex system;

a hypertext outliner with multilevel autonumbering and permanent identifiers attached to each outline node for use as hypertext link anchors, plus view specifications that can be embedded within links or used interactively;

a set of hyper-button types that provide core hypertext and other behaviors; and

a set of programming library classes for system developers who want to integrate the package with other user interfaces or as a back-end to a distinct system.

The features offered by these components include:

hypertext buttons that can link to information or execute procedures, e.g. starting or communicating with external programs;

mouse dragging from a button source location to its link destination to create a new link;

embedding buttons within email messages;

creating outlines for rapid browsing, editing and moving of chunks of information organized into trees; and

encapsulating other hypertext and information retrieval systems under the Hyperbole user interface.

Hyperbole is freely available under the GPL. It is written entirely in Emacs Lisp, and a complete online HTML manual is available.
[http://www.BeOpen.com/products/hyperbole/hyperbole_overview.html]
Hyperlatex: A package that allows the use of LaTeX to prepare documents in HTML and hardcopy. It provides an authoring environment for writing printed documents and HTML documents at the same time, using an extended subset of LaTeX which excludes concepts that have no HTML counterpart and adds commands for HTML concepts such as hyperlinks or included images. The author was dissatisfied with LHTML and decided to follow the model of Texinfo rather than that of LaTeX2HTML when developing Hyperlatex. The use of this requires the Emacs editor. See also HyperTeX, LaTeX2HTML, Ltoh, tex2pdf, Tex2RTF, TeX4ht, and tth.
[http://www.cs.ust.hk/~otfried/Hyperlatex/
Hypermail: A program that takes a file of mail messages in UNIX mailbox format and generates a set of cross-referenced HTML documents. The features include:

creation of a HTML file for each separate message in the email archive containing links to other articles;

links to the next and previous messages, the message to which to article is replying, and to the next article in the current thread;

incremental updating of Hypermail archives (with default updating only when changes are detected);

conversion of references in messages email addresses, URLs to hyperlinks, and email addresses to mailto: URLs or links to a CGI mail program; and

creation of index files for each set of messages which sort the articles by date received, thread, subject and author (with each entry linked to the appropriate article(s).

A source code distribution of this C program is available.
[http://www.landfield.com/hypermail/]
HyperNews: A cross between the hypermedia of the WWW and Usenet news. Readers can respond to any articles or responses they read in the HyperNews web. The articles support moderate organization of information, while the responses support unmoderated discussion about the information. HyperNews doesn't use the NNTP news mechanism for transferring articles to sites and their is not yet a gateway to news. Responses and base articles are maintained by whoever writes them in their own disk space. Sounds like an interesting choice for a local BBS. The source code is available and, since it's written in Perl, should install and run on generic UNIX platforms with a Perl installation.
[http://www.hypernews.org/HyperNews/get/hypernews.html]
HyperTeX: The folks who developed this state that "it is easier to add hypertext capability to TeX than to simulate the TeX typesetting environment within www browsers" (which is what LHTML attempts to do). The gist of the HyperTeX paradigm is to insert TeX "
special" commands to add the necessary structure to the .dvi file. This structure will be ignored by .dvi processors that don't understand it, and properly processed by those that do. An example of the latter is a modified xdvi previewer called xhdvi. See also Hyperlatex, LaTeX2HTML, Ltoh, tex2pdf, Tex2RTF, TeX4ht, and tth.
[http://xxx.lanl.gov/hypertex/]
HYPOELLIPSE: A program for determining the hypocenters of local or near regional earthquakes and for each event the ellipsoid that encloses the 68% confidence volume. Travel times are determined from a horizontally-layered velocity-structure, from a linear increase of velocity with depth, from a linear increase of velocity over a half-space, or from a previously generated travel-time table. With the travel-time-table option, gradients are allowed in all layers, but there can be no velocity discontinuities. Arrival times for the first arrival of P waves and S waves, and S-minus-P interval times can be used in the solutions. Arrival times for refractions, such as Pn, even at distances where they do not arrive first, can also be used. Each arrival can be weighted according to the reading clarity, the epicentral distance to the station, and the deviation of its residual from the mean. The hypocenter is found using Geiger's method to minimize the root-mean-square (RMS) of the travel-time residuals. The magnitude of each event is calculated from the maximum amplitude and/or the signal duration. The program includes a station history database, so that magnitudes will always be computed with the correct response function and gain. First motions can be plotted using an equal-area, lower-hemisphere, focal projection. The azimuth and apparent velocity of a plane wave crossing the array from a distant source can also be determined.
A source code distribution is available. It is written in Fortran 77 and has been compiled on a Sun machine, but I don't think it'd take much to get it going with g77. A fairly large user's manual is available in flat ASCII format.
[http://lahr.org/iaspei/northam/ak/s_ak/programs/hypoel/hypoel.html]
Hypre: A library of linear system preconditioners that can be used standalone or invoked from other related toolkits. It currently (7/00) implements a serial algebraic multigrid preconditioner, serial and parallel structured multigrid preconditioners, a parallel ILU, and a parallel sparse approximate inverse. This is not yet available.
[http://acts.nersc.gov/hypre/]
HyTech: An automatic tool for the analysis of embedded systems. HyTech is a symbolic model checker for linear hybrid automata and has the capability of performing parametric analysis, i.e. given a parametric description of an embedded system as a collection of communicating automata, it automatically computes the conditions on the paramters under which the system satisfies its safety and timing requirements. A source code version of this C++ package is available as are binaries for several systems including Linux Intel.
[http://www-cad.eecs.berkeley.edu/~tah/HyTech/]
HyTime: The Hypermedia/Time-based structuring language provides facilities for representing static and dynamic information that is processed and interchanged by hypertext and multimedia applications. This is an application of SGML that supports the classic bibliographic model of information referencing wherein it is possible to represent links to anything, anywhere, at any time, and in a variety of ways. It provides standarized mechanisms for specifying interconnections (i.e. hyperlinks) within and between documents and other information objects as well as for scheduling multimedia information in time and space. The architectural forms and attributes of the HyTime language are grouped into five modules with both required and optional facilities:

base module - consisting of independent utility facilities with the required ones supporting hyperdocument management (via SGML) and identification of object properties;

location address module - allows the identification of objects that cannot be addressed by SGML unique identifiers as well as those that are external documents;

hyperlinks module - allows relationships (i.e. hyperlinks) to be established among objects within a single document or among many documents comprising a hyperdocument;

scheduling module - allows events (i.e. occurrences of objects) to be scheduled in such a way that their positions can be expressed in terms of their interrelationships; and

rendition module - for specifying parameters governing the rendition process, e.g. object modification and event projection.

[http://www.oasis-open.org/cover/hytime.html]
[http://www.hytime.org/]

[ home / linux ]

Next: Ia-Im Up: Linux Software Encyclopedia Previous: Ha-Hm Contents

Manbreaker Crag 2001-03-08