Next: Tn-Tz Up: Linux Software Encyclopedia Previous: Sn-Sz Contents

Ta-Tm

Last checked or modified: Jan. 8, 2001

TAGL: A library which provides a subset of the functionality of the SGI GL library. TAGL was designed to be portable and extensible with features including:

a portable framebuffer class;

virtual constructors;

convex polygon clipping;

dithering;

RGB emulation in 8bpp mode;

zbuffer and texture mapping;

built-in sine and cosine tables;

3-D transform matrices; and

blitting and bitmap scaling.

It works for 8, 15, 16, 24, and 32 bpp displays.
A source code distribution of TAGL is available. It is written in C++ an can be compiled and used on most UNIX platforms. On Linux platforms in can be used with either X11 or SVGALib. The documentation is sparse.
[http://sunsite.unc.edu/pub/Linux/libs/graphics/]
TAL: The Technical Analysis Library is an object-oriented library written in Eiffel that provides functions for the construction of technical market analysis applications, e.g. a stock charting application. A command line application is also included with the library. It includes several common technical indicators such a moving averages, moving average convergence/divergence (MACD), momentum and stochastic. A source code distribution is available.
[http://www.eiffel-forum.org/archive/cochrane/tal.htm]
Tamaya: The name of this software has been changed to Amaya.
TAMC: The Tangent linear and Adjoint Model Compiler is a source to source translator that generates Fortran routines for the computation of the first-order derivatives of other Fortran routines. It provides automatic differentiation in forward and reverse mode for Fortran programs. The derivatives are computed in the reverse mode (adjoint model) or in the forward mode (tangent-linear model), with Jacobian matrix products computed in either mode.
The features of TAMC include:

support for Fortran 77 and 90 and several extensions;

support for some HPF extensions;

several normalization features including placing saved variables in addition COMMON blocks, function clones for entry statements, inline statement functions, replacing expressions in argument lists, replacting alternative and alternate returns, etc.;

control flow analysis, i.e. constructing and reducing a control flow graph and node splitting for irreducible acyclic subgraphs;

data dependence analysis including constant propagation, induction variable substitution, reduction variable detection, and scalar variable privatization;

data flow analysis including forward and backward structural analysis, and detection of active variables, common blocks, subroutines, functions, modules and files;

adjoint code generation with vector- or matrix-Jacobian products, expression splitting, a pure mode to compute only derivatives, and generation of adjoint file operations;

recomputations including reverse data flow analysis and insertion of only needed recomputations;

a forward mode with expression splitting and generation of tangent linear file operations.

The GAMC package is freely available for non-commercial usage. It is documented in a user's manual as well as in several technical reports.
[http://puddle.mit.edu/~ralf/tamc/tamc.html]
TAO: The Toolkit for Advanced Optimization was designed for large-scale optimization problems. The methods used include nonlinear least suares, unconstrained minimization, bound constrained optimization and general nonlinear optimization. The design philosophy is to use object-oriented techniques to create a flexible toolkit for use within serial and parallel environments, with design decisions strongly motivated by the challenges inherent in the use of large-scale distributed memory architectures and working with large and often poorly structured legacy codes for specific applications. A strong emphasis is also placed on the reuse of external tools, e.g. lower level linear algebra support and higher level application frameworks.
The TAO solvers use four fundamental objects to define and solve optimization problems: vectors, index sets, matrices, and linear solvers. The concepts of vectors and matrices are standard, while an index set refers to a set of integers used to identify particular elements of vectors or matrices. The optimization algorithms consist of a sequence of well defined operations on these objects. These operations include vector sums, inner products, and matrix-vector multiplication. TAO makes no assumptions about the representation of these objects by passing pointers to data-structure-neutral objects to external libraries for the execution of these numerical operations.
The current (10/00) TAO implementation uses the parallel system infrastructure and linear algebra provided by the PETSc environment and MPI for interprocessor communication.
[http://www-fp.mcs.anl.gov/tao/]
taper: A user friendly archive program especially designed for backup up to tape drives (although it also supports backing up to disk). A useful feature is the maintenance of an archive information file on the hard disk containing all of the essential details about the contents of the tapes. The information can be reconstructed from the tapes themselves should it vanish or become corrupted. A source code distribution of taper is available. A user's manual is included.
[http://www.e-survey.net.au/taper/]
[http://sunsite.unc.edu/pub/Linux/system/backup/]
TAPES: The Terrain Analysis Programs for the Environmental Sciences are for using topographic data to derive terrain attributes describing the shape (i.e., morphology) of the landscape and the influence of topography on environmental processes such as water flow and solar radiation. There are two versions of the TAPES programs:

TAPES-G, which uses grid Digital Elevation Models (DEMs); and

TAPES-C, which uses contour data.

The contents of the TAPES-G program set include:

TAPES-G, a grid-based topographic analysis program;

SRAD, for computing solar radiation and temperature based on topography;

WET, for computing a wetness index, soil wetness and evapotranspiration;

DYNWET, for computing a modified wetness index accounting for the limited time available for water to drain from upslope areas;

EROS, for computing a potential soil erosion index;

EVAP, an old version of WET that uses either a static or dynamic wetness index;

UPSUMG, computes upslope average values of selected topographic attributes;

SHADEDEM, computes a shaded relief image from a DEM;

FRACT, for spectral analyis of DEM surfaces which is used for determining a fractal dimension;

FREQ-G, computes frequency histograms and fits several probability distributions;

TAPESTOARC, for converting TAPES-G files into a format appropriate for ARC/INFO;

ATTRIBUTES, a graphical display program for visualizing the outputs of the analysis programs; and

FREQ, computes frequency histograms of attributes computing by the analysis programs.

The TAPES-C program set contains:

TAPES-C, a contour-based topographic analysis program;

PREPROC, a data preprocessing program;

PLOTCON, another data preprocessing program;

EDITCON, a graphics-based contour and point editing program;

THALES, a dynamic hydrologic simulation program using the surface discretization of TAPES-C;

THALCH, an interface program to transform TAPES-C output into THALES input; and

the ATTRIBUTES and FREQ programs previously described.

Both program sets are written in Fortran 77 and C for UNIX platforms. The C programs are written in K&R rather than ANSI C but can be compiled with gcc. The X11 interface uses the Xaw widget set. See Moore and Grayson (1991) and Moore et al. (1993).
[http://cres.anu.edu.au/outputs/tapes.html]
tar: The tape archive program can be used to create as well as process already existing tar archives. This provides an organized and systematic method for controlling large amounts of data in many files. The name comes from its original use to create archives on actual magnetic tapes, although current versions can direct output to most available devices, e.g. tapes, files, other programs, remote devices, etc.
[http://www.gnu.org/software/tar/tar.html]
TARDEM: A suite of programs for the analysis of digital elevation model (DEM) data. The programs can be divided into those for grid and raster preparation and those for channel network extraction. Those in the former category include:

flood, inputs an elevation data grid and creates an output file with pits filled using a flooding algorithm;

D8, inputs a pit filled elevation file and creates an output file containing D8 flow directions and slopes for each grid cell;

Dinf, assigns a flow direction for each cell based on steepest slope on a triangular facet;

Aread8, inputs a D8 flow direction file and creates an output file containing the contributing area;

Areadinf, inputs a Dinf angle file and creates on output file containing the contributing area;

Asfgrid, takes as input a slope and area file and creates an output file containing a list of areas and slopes as well as statistics of these binned to help decide the appropriate support area threshold for channel network extraction;

Hack, computes the path length and total path length to each grid point; and

Sourcedef, inputs slope, area and pathlength files and creates an output grid file defining a network mask according to a variety of rules for channel sources.

The programs for channel network extraction include:

Netex, inputs D8 direction and contributing area files and outputs a network connectivity tree;

Netprop, determines network properties for networks found by Netex;

Linkan, computes link properties associated with a channel network;

Streaman, computes Strahler stream properties;

arcstreams, computes streams in Arc/Export format;

Arclinks, creates output links in Arc/Export format;

Asflinks, creates a list of areas and slopes as well as binned statistics for deciding the appropriate support area threshold for channel network extraction; and

Sscale and Sscale2, summerize properties of Strahler streams for constant drop analysis.

Source codes are available for all programs, some of which are written in Fortran and some in C.
[http://www.engineering.usu.edu/cee/faculty/dtarb/dem.htm]
TargetJr: A large, integrated image understanding (IU) environment designed both as a computer vision research tool and as a platform for building end-user applications. The core of the package is a collection of C++ class libraries with particular emphasis on a geometric approach to image analysis. The libraries provide the functionality needed for vision research from basic C++ containers and numerical algorithms through image processing to tools for modeling solid objects and performing complex geometric manipulations. It also provides a GUI for the display of images, 2- and 3-D geometry, and generic user-interface controls.
TargetJr is divided into several packages which are groups of related class libraries with common purposes. The generic C++ libraries not specific to image processing or vision research are:

COOL, an object-oriented library that provides a user-friendly set of tools on top of C++;

GeneralUtility, general programming support classes providing directory parsing, reference counting, ASCII import/export of classes, numerical methods, socket I/O and smart pointers;

Interviews, a graphics library providing image display, superimposition of primitives on images, menus and other useful features;

Fresco, an updating of Interviews;

Database, generic relational database support classes; and

Numerics, support functions for (mostly) linear algebra.

The computer vision and image understanding libraries are:

Image, for reading and writing various image formats;

Spatial Objects, for representation of geometry and topology including digital curves which are derived from image segmentation;

Geometry, for representation of geometry;

Topology, for representation of topology;

ImplicitLineGroup, part of the spatial objects hierarchy;

MultiView, for representing and computing with the geometry of multiple images;

Photogrammetry, for types of image projection such as perspective and graphics display cameras; and

Segmentation Algorithms, for extracting geometric representations from an image.

A GUI called Viewing provides a simple and powerful way of displaying 2- and 3-D geometry on images. Applications built using the libraries include:

xcv, a sort of xv for computer vision that provides an array of useful functions;

SiteModeling, a 3-D geometry editor; and

Morse, an application for invariant object representation that includes a recognition system.

Source code distributions of all portions of the package are available. Documentation is available in the form of user's manuals for most of the packages in PostScript format.
[http://www.targetjr.org/]
TAU: The Tuning and Analysis Utilities are a set of tools for analyzing the performance of parallel application programs. It is used by inserting TAU macros for program instrumentation into source code, compiling and running the program to generate a trace file, and then viewing the trace file with various TAU tools. It is similar to the UNIX prof and gprof utilities although it gathers much more information. The functionality of TAU includes:

per-process, per-thread and per-host information;

inclusive and exclusive function times;

profiling groups that allow data collection organization;

access to hardware counters;

per-class and per-instance information;

separate data for each template instantiation;

start/stop timers for profiling arbitrary sections of code; and

support for the collection of stats about user-defined events.

TAU is integrated with other ACL software components such as POOMA and SMARTS.
A source code distribution of TAU is available. It has been tested on several platform/compiler combinations including Linux Intel with g++ 2.7.2.3. It should probably also work with egcs. Documentation is available at the site in hypertext format.
[http://www.acl.lanl.gov/tau/]
[http://acts.nersc.gov/tau/main.html]
TauP: A toolkit of flexible seismic travel-time and raypath utilities. The programs in this Java package include:

taup_time, for calculating travel times;

taup_pierce, calculates pierce points at model discontinuities and specified depths;

taup_path, calculates ray paths and depth versus epicentral distance;

taup_curve, calculates travel times for a range of depths and distances;

taup_table, outputs travel times for a range of depths and distances in an ASCII file;

taup_setsac, puts theoretical arrival times into sac header variables;

taup_create, creates a .taup model from a velocity model; and

taup_peak, peeks at a saved model (for debugging).

[http://www.seis.sc.edu/software/TauP/]
Taylor UUCP: A complete UUCP package covered by the GPL. It includes several user programs, most of which are based on programs from earlier UUCP packages. These programs are:

uucp, which is used to copy files between systems;

uux, which is used to request the execution of a program on a remote system;

uustat, which can do several things including listing queued uucp or uux jobs, removing those jobs, and showing the status of the UUCP system in various ways;

uuname, which lists all of the remote systems your system knows about;

uulog, which displays entries in the UUCP log file;

uuto and uupick, shell scripts to transfer and retrieve files using using uucp; and

cu, which can call up another system and communicate with it as though you are directly connected.

Most of the work is done by two daemon processes:

uucico, which actually calls the remote system and transfers files and requests; and

uuxqt, which processes execution requests made by the uux program on remote systems.

A source code distribution of Taylor UUCP is available. It is written in C and can be compiled and used on many types of platforms using the configure script supplied with the distribution. It is documented in an extensive user's and reference manual included in Texinfo format.
[ftp://ftp.gnu.org/pub/gnu/uucp/]
tcc: An implementation of a compiler for the `C or Tick-C language. Tick-C is an extension of ANSI C that provides the programmer with the ability to explicitly denote dynamic code generation (i.e. the creation of executable code at runtime) at the level of C statements and expressions. Dynamic code generation allows the use of runtime information to improve code quality (e.g. in the areas of strength reduction and dead code elimination) and also provides a key technology for the development of just-in-time compilers, compiling interpreters and other components of modern mobile code and other adaptive systems.
The tcc compiler is an efficient implementation of `C that allows the tradeoff of dynamic code quality for dynamic code generation speed. For example, if compilation speed must be maximized, dynamic code generation and register allocation can be performed in one pass - and if code quality must be maximized, the compiler can construct and optimize an intermediate representation prior to generating code.
A source code distribution of tcc is available. It currently (10/98) only produces code for DEC Ultrix and Sun SunOS and Solaris platforms although a port for the Intel x86 architecture is in the works. It can also work as a cross-compiler for the architecture implemented by the SimpleScalar simulator tool set. This implementation is based on the lcc compiler. Several technical reports and a tutorial are available.
[http://pdos.lcs.mit.edu/tickc/]
TCCS: The Trivial Configuration and Control System is a freely available system for project control, i.e. a simple and powerful form of software configuration management. TCCS is implemented as a front-end to the two widely used source control systems RCS and SCCS. It provides a common command-line interface to both systems and extends them by supporting multi-release, multi-user, multi-platform development.
The features of TCCS include:

each tree of archive files becomes a project, the root of a set of related trees automatically administered by the system;

public snapshots or checkpoints of project sources can be defined to record the exact files current at a given point;

checkpoints can be later deleted or recreated and one checkpoint can patch another;

private source trees or work areas can be attached to checkpoints and will transparently use checkpoint sources when no sources are locally present in the work area, i.e. the work area is backed by the checkpoint;

a given backing chain of source trees can be built for multiple target environments using related but separate build trees;

the tools needed to build for a given target environment are recorded in toolsets; and

platform descriptions are used to describe how to apply toolsets in particular builds.

A source code distributions of TCCS is available for non-commercial uses. This is documented in Bolinger and Bronson (1995).
[http://www.oreilly.com/homepages/tccs/]
TCFS: The Transparent Cryptographic File System is a sort of extended NFS which allows a user to protect files using encryption techniques. TCFS works as a layer under the Virtual File system Switch (VFS) layer which makes it transparent to all applications. The data encryption standard (DES) is used to provide the encryption with the keys kept in a special database which stores them encrypted with the user's login password. It was designed to ensure than secured files aren't readable by any user other than the owner, by tapping into communication lines between the user and the remote server, and by the superuser of the server. The filenames as well as the files are encrypted in the TCFS.
On a TCFS installation files are stored in encrypted form on the server with a different key for each user. The key is provided by the user via the tcfslogin utility. A requested file is passed from the server to a client in encrypted form and decrypted by the client before being passed to an application. Similarly, a file written to the server is first encrypted with the user's key on the client and then passed to the server, with the key never leaving the client for either operation. Thus the only data that passes between the client and server is in encrypted form.
A source code distribution of TCFS is available. Installation and use requires an NFS server running Linux with the EXT2 file system, and it must also be used with 2.0.X kernels. It can be used as a kernel module or compiled into the kernel. It is documented in a user's manual available in PostScript format as well as in an article in the August 1997 Linux Journal.
[http://tcfs.dia.unisa.it/]
TCGMSG: See the Global Array package.
TCL Developer Studio: A development environment for working with Tcl projects.
[http://www.star.spb.ru/~small/tcldev/]
Tcl Plugin: See under Netscape.
tcl-debug: A debugger for Tcl.
[http://expect.nist.gov/tcl-debug/]
tcLex: A lexical analyzer generator extension to Tcl written in C. This is similar to other lexers except it uses the Tcl philosophy and syntax. The features include:

cross-platform support, i.e. on any platform on which Tcl is supported;

dynamic generation of Tcl commands that can be used like other C commands or Tcl procedures from within Tcl scripts or C programs;

use of Tcl regular expressions; and

maintenance of state by the generated lexer commands, i.e. they can be used in one pass or incrementally.

A source code distribution is available.
[http://www.multimania.com/fbonnet/Tcl/tcLex/]
Tclmidi: A language designed for creating and editing standard MIDI files which will also play and record MIDI files with the proper device interface. The language supports function calls, recursion, and conditionals and can be used for editing, sequencing, and writing complex scripts. Tclmidi is based on Tcl/Tk and adds some new commands specific to manipulating, playing, and recording MIDI files. It comes with device drivers to interface with some MIDI cards as well as support for using the serial port as a MIDI interface. The supported cards include MPU401, MQX32, Gravis Ultrasound (GUS), and SoundBlaster. Work is under way to use the GUS to generate its own sound. The most recent (5/97) versions of Tclmidi is 3.1.0 and is a loadable module which works with Tcl 7.5, i.e. it works with the standard tclsh or wish interpreters rather than as a standalone executable.
The source code for Tclmidi is available. It is mostly POSIX-compliant and written in C++. The supplied makefile supports BSD, Linux, FreeBSD, NetBSD, and Unixware platforms. Tcl 7.5 or greater is required to use Tclmidi. There is a related Tk-based sequencer with uses the Tclmidi extensions and is avaiable from the same site.
[http://jagger.me.berkeley.edu/~greg/tclmidi/]
[http://nswt.tuwien.ac.at/htdocs/internet/unix/sound/tclmidi.html]
[http://harmony-central.com/Software/Unix/]
TclProp: A data propagation formula manager for Tcl/Tk which allows Tcl programmers to define formulas among variables using a declarative style of programming wherein the formulas are maintained by the system so the variables are always consistent. This style is particularly useful for building user interfaces, i.e. applications can be defined around a small set of state variables and information on the display (e.g. when a button should be active or what text a label or button should display) can be maintained locally in formulas. This comes with an example program in the form of a video poker application called TkVP.
[http://www.cs.umn.edu/Research/GIMME/]
Tcl/Tk: The tool command language is an embeddable scripting language and Tk is a graphical user interface toolkit based on Tcl. Tcl is an interpreted language which can be configured to work co-operatively with other languages such as C or C++. It is highly portable and known to compile and run easily on most UNIX systems including Linux. It is a component used in quite a few of the other software packages you'll find in these pages. A nice introduction to programming in Tcl/Tk can be found at the Tcl/Tk Cookbook. An introduction and tutorial on how to build GUI interfaces with this software is Developing GUIs with Tcl/Tk/Expect. See Maggiano (2000), Ousterhout (1994), Welch (1995), and Young (1997).
Software packages which extend or use or support Tcl and/or Tk in some way include: Ara, aXe, beast, BibTool, BLT, btng, CACTVS, Cecilia, CG, CML, CMT, Condor, Coral, CoST, DATAPLOT, DejaGnu, Delve, Drone, DSU, ET, exmh, Expect, FastCGI, Fred, FTOOLS, GAGS, GALOPPS, GGK, GOOD, Grail, Graphlet, GroupKit, Guile, Hush, IKIT, ILU, [incr Tcl], IrTcl, isc, Jacl, jTcl, LINK, LONI, TkLua, Mariposa, MG, MGGHAT, MMM, mSQL, MtScript, NeoWebScript, NetPlug, NR, OCRchie, OmniMoni, Oorange, OPAL, OSIMIS, Oz, Pacco, PADE, Pad++, perlTk, Picasso, Pisces, PLplot, Point, PostgreSQL, ptcl, PVS, Qddb, Qist, QMG, Ratatosk, REGAL, Rivet, Rivl, Scotty, SHORE, Sift-Mail, SIMEX, SSAT, STk, Studio, SurfIt, Swarm, SWIG, Tcl-DP, Tclmidi, TclProp, tclpvm, TDG, TIGER, TiMidity, Tix, TKAPPS, TkDesk, TkfPW, TkGoodStuff, Tkpvm, TkSM, TkStep, tkWWW, TMath, Togl, TSIPP, Tycho, Uts, vat, VMail3, VMD, VPE, Vtk, Wafe, WEKA, X-CD-Roast, XF, X-pole, xtem, and EuLisp.
[http://www.tclconsortium.org/]
[http://www.scriptics.com/]
[http://www.unifix-online.com/tcltk/]
TCM: The Toolkit for Conceptual Modeling is a collection of software tools to present conceptual models of software systems in the form of diagrams, tables, trees, and the like, where a conceptual model of a system is a structure used to represent the behavior or decomposition of the system. TCM is meant to be used for requirements engineering, i.e. the activity of specifying and maintaining requirements for desired systems, in which a number of techniques and heuristics for problem analysis, function refinement, behavior specification, and decomposition specification are used. TCM takes the form of a suite of graphical editors to perform the various tasks of requirements engineering.
TCM contains graphical editors for several kinds of documents, diagrams, tables, and trees. There are editors for generic graph diagrams, entity-relationship diagrams, class-relationship diagrams, state transition diagrams, recursive process graphs, data (and control) flow diagrams, and JSD process structure and system network diagrams. Editors are available for various tables including generic, transaction decomposition, transaction-use, and function entity-type tables as well as for generic textual and function decomposition trees. TCM supports constraint checking for single documents (i.e. name duplication, cycles in is-a relationships), distinguishes built-in constraints (of which a violation cannot even be attempted) and soft constraints (against which the editor provides a warning when it checks the drawing), and is planned to eventually support constraint checking across documents.
TCM is available in binary form for various platforms including Sun Solaris (for Sparc and X86), Sun SunOS, Linux Intel, SGI IRIX, and IBM AIX. The use of TCM requires Motif although the binaries are available with Motif both statically and dynamically linked. The package is documented in a user's manual available in PostScript format. See also Wieringa (1996).
[http://wwwhome.cs.utwente.nl/~tcm/]
tcpdump: A tool for network monitoring and data acquisition. Tcpdump creates tcdump trace files which contain huge amounts of information about what's happening on a network. Additional programs are usually used to reduce the amount of tcpdump data when looking for a particular problem. The tcdump package contains a few awk programs for doing this: send-ack, which simplifies the tcdump trace for an FTP or a similar unidirectional TCP transfer; packetdat, which computes chunk summary data for an FTP or a similar unidirectional TCP transfer; and stime and atime, which output one line per send or acknowledgement.
The tcpdump source code is available and can be compiled and installed on most generic UNIX platforms via the use of the autoconfig script included in the package. The installation of this requires the prior installation of libpcap. This package is documented in a man page and in several ASCII files in the distribution.
[http://www.tcpdump.org/]
[ftp://ftp.ee.lbl.gov/]

XTcpdump

A GUI front-end for tcpdump.
[http://geekcorp.com/xtcpdump/]
TCP/IP: A generic term usually referring to anything related to the specific protocols of either TCP or IP, although it can include other protocols, applications, and even the network medium. TCP stands for Transmission Control Protocol and is the major transport protocol in the Internet suite of protocols. It uses IP, the Internet Protocol, for delivery, IP is the network layer protocol for the Internet protocol suite. RFC 1180 recommends ``internet technology'' as a more accurate term rather than TCP/IP. See Black (1995b), Bradner and Mankin (1996), Carl-Mitchell and Quarterman (1993), Cypser (1991), Feit (1996), Hall (2000), Halsall (1996), Hunt (1992), Hunt (1995), Matusow (1996), Naugle (1993), Parker (1996), Perlman (1992), Piscitello and Chapin (1993), Potts and Black (1992), Santifaller (1995), Stevens (1994), Stevens (1995), Stevens (1996), Taylor (1995), Thomas (1996), Udupa (1995), Washburn and Evans (1993), Wilder (1993), and Wright and Stevens (1995).
[http://t2.technion.ac.il/~s2845543/tcpip_rl.html]
[http://ipprimer.2ndlevel.net/]
[http://www.itprc.com/tcp_ip.htm]
[http://www.3com.com/nsc/501302s.html]
[http://www.redbooks.ibm.com/abstracts/gg243376.html]
[http://www.faqs.org/rfcs/rfc761.html]
[http://www.faqs.org/rfcs/rfc760.html]
TCP_wrappers: A daemon that stands between the Internet daemon inetd and network daemons such as in.telnetd and in.ftpd to control access to almost all TCP network services. The Internet daemon is reconfigured to run the wrappers instead of the ordinary network daemon, and the wrappers check both the source address of the connection and the service requested to decide if the connection to to be allowed. Both allowed and disallowed requests are written to the system logs, and the wrappers can be configured to run shell commands when certain services requested to set booby traps for suspected intruders.
The TCP_wrapper configuration is set in a pair of files called hosts.allow and hosts.deny which contain rules which match particular services and computer host names. The rules allow a great deal of flexibility and can range from allowing a mostly closed system to a mostly open system and anything in between. Advanced options can also be compiled into the code which allow even more powerful extensions to be added to the basic access controls. Two utility programs, tcpdchk and tcpdmatch, are included which check the validity of the configuration files and test a configuration against a virtual request for a connection, respectively.
A source code distribution of TCP_wrappers is available. It can be compiled and installed on many UNIX flavors, including Linux, although all major Linux distributions come with it already installed as part of the networking package. It is documented in a series of man pages as well as in Garfinkel and Spafford (1996). There is an article about TCP_wrappers in the August 1997 Linux Journal.
[ftp://ftp.porcupine.org/pub/security/]
[ftp://ftp.cerias.purdue.edu/pub/tools/unix/netutils/tcp_wrappers/]
tcsh: An enhanced yet completely compatible version of csh. It is a command language interpreter that can be used as either an interactive login shell or a shell script command processor. The features of tcsh usually not found in csh implementations include:

a command-line editor that supports Emacs or vi style key bindings;

programmable and interactive word completion and listing;

spelling correction of filenames, commands and variables;

editor commands that perform other useful functions in the middle of typed commands, e.g. documentation lookup, quick editor restarting and command resolution;

an enhanced history mechanism wherein, e.g. events are time-stamped;

enhanced directory parsing and directory stack handling;

negation in glob patterns;

new file inquiry operators;

a variety of automatic, periodic and timed events including scheduled events, special aliases, automatic logout and terminal locking, command timing and watching for logins and logouts;

support for the Native Language System, OS variant features, and system-dependent file locations;

extensive terminal management capabilities;

several new built-in commands;

several new variables that make useful information easily available to the shell;

a new syntax for including useful information in the prompt string; and

read-only variables.

See DuBois (1995).
[http://www.ibiblio.org/pub/Linux/system/shells/]
[ftp://ftp.astron.com/pub/tcsh/]
[http://www.primate.wisc.edu/software/csh-tcsh-book/]
[http://wwwcip.informatik.uni-erlangen.de/tree/tcsh/top.html]
[http://hegel.ittc.ukans.edu/topics/linux/man-pages/man1/csh.1.html]
TDG: The Dotfile Generator is tool to aid users in interactively configuring both basic and advanced features in several well-known programs via a graphical user interface. The are currently (5/97) TDG modules for bash, Elm, Emacs, Fvwm, rtin, and tcsh (with modules for procmail, ipfwadm, and Apache in the works).
The TDG source code is available. It is written in Tcl/Tk and requires at least Tcl 7.4 and Tk 4.0 for installation and use. Documentation includes a programmer's manual in PostScript format as well as several online documents.
[http://www.blackie.dk/dotfile/]
TDLIB: A C++ computational thermodynamics library intended for the thermodynamic assessment of phase diagrams. It consists of three parts:

PHASE, a framework for modeling the Gibbs energy of multi-component solutions;

TD_ALGO, various thermodynamic algorithms; and

VARCOMP, for simultaneous thermodynamic assessment.

[http://www.chem.msu.su/~rudnyi/tdlib/]
Teak: A planned (5/97) GNU desktop interface intended to enable users with minimal computer experience to browse the file system, launch programs, and perform essential file manipulations. Teak is still in the planning stages.
[http://www.gnu.ai.mit.edu/software/teak/teak.html]
Teapot: The Table Editor And Planner Or Teapot is a spread sheet program for UNIX which in addition to being portable and extensible includes such modern concepts as 3-D tables and iterative expressions.
The features of Teapot include:

the functional addressing of cells which results in an easily understandable syntax and very powerful semantics based on very few basic functions;

the possible use of a third dimension (i.e. like multiple layers on top of each other);

typing all values with operations and functions that check types;

the use of iterative expressions;

a spread sheet format defined using XDR to ensure portability across machines (as well as an optinal ASCII format for ease of file manipulation);

extensibility via new functions written in C;

the use of X/OPEN message catalog support for all messages; and

interfaces to troff/tbl, LaTeX, HTML, and CSV for output flexibility.

Teapot is written in ANSI C and should compile on most POSIX compliant systems. It's use requires SYSV curses or its clone ncurses and the Sun XDR library, both of which are freely available. It is known to work on Sun Solaris, HP-UX, Linux Intel, FreeBSD, and DEC Ultrix platforms and is probably easily transportable to others. Documentation is available in the form of a user's guide available in ASCII and PostScript format. See also MacroCALC.
[http://www.moria.de/~michael/teapot/teapot-en.html]
Tecate: A software platform for the exploratory visualization of data collected from networked data sources. The original goal of the project was to provide an environment in which Earth scientists could browse and visualize data over the Web, with the goal now broadened to providing tools for any user to visually explore general data spaces (i.e. any data source or repository whose access is controlled via a well-defined software interface). As such it provides interfaces to the Web and to databses managed by database management systems (DBMs).
The unique features of Tecate include its design to provide application programs with the ability to interface with general data spaces, to automatically map data into appropriate visualizations, and to manage user-interactions with elements in those visualizations. It also makes use of an expert system to help create virtual worlds that represent selected data sets. It takes into account the structure of the data sets and user data analysis goals to automatically write programs that build representative data visualizations when executed. Tecate also makes use of an interpreted language called AVL to specify the contents of virtual worlds, i.e. it is both a 3-D description language and a full-fledged programming language that can handle user interactions and communication between different processes.
The Tecate source code is freely available and has been tested on DEC Alpha and SGI Irix systems, although it should compile and run on most UNIX platforms that are conversant with OpenGL. Several papers and technical reports about Tecate are available in PostScript format.
[http://www.sdsc.edu/Tecate/tecate.html]
TECForM: The Template Extended CGI Form Mailer is a versatile form processing script that allows the creation of almost any desired form. The features include specifying which fields are mandatory, specifying regular expressions for fields, and setting error messages or documents called when the content of a field does not meet the correct criteria. Adminstration features are also included. Use of this requires Perl 5.
[http://www.xs4all.nl/~rmeijer/tecform.htm]
Ted: A word processor for UNIX platforms that creates documents in Rich Text Format (RTF). All documents produced by Ted can be imported into Microshaft Word, although the opposite is not true since Word is deliberately designed to remain incompatible with anything but its latest ``upgrade.'' The features of Ted include:

WYSIWYG rich text editing with all fonts for which an .afm file and X11 font are available;

use of Microshaft's RTF as a native text format such that all documents produced by Ted can be read by Microsloth products and a goodly amount of documents produced by Microsloth products can be read into Ted;

in-line bitmap pictures;

output to PostScript format;

spell checking in several languages;

direct mailing of document from within the program;

cutting/copying/pasting as well as with other applications;

find/replace;

indentation of paragraphs and first lines, tabs, and a copy/paste ruler;

page breaks;

tables;

support for symbols and accented characters;

hyperlinks; and

saving documents in HTML format.

Source code and binary distributions are available for Linux platforms.
[http://www.nllgg.nl/Ted/]
TeD: An X Window-based text editor. The features include a fully configurable keyboard, multiple windows, multiple files, and the ability to copy and paste between files/windows, undo and redo capability for most commands, powerful rectangle block and line block operations, a history of typed commands, mouse select and paste support, and a small executable file size. This was developed on a Linux box.
[http://www.ibiblio.org/pub/Linux/apps/editors/X/]
TEItools: A collection of scripts for transforming documents written in SGML to various ouput formats including HTML, LaTeX, RTF, PostScript, and PDF. The source file format used is the TEI Lite form of SGML. The package is written as a combination of shell scripts and Tcl.
[http://xtalk.price.ru/SGML/TEItools]
Tela: The Tensor language is a scientific computing language and environment mainly targeted for prototyping and performing pre- and post-processing tasks for large-scale numerical simulations. As such its features are biased towards those needed to solve partial differential equations. This is indeed a prototyping package so even though modest-sized 2-D simulations can be done in a reasonable amount of time it probably wouldn't be a good idea to attempt large 2-D or 3-D simulations.
The features of Tela include:

a complete Fortran 90 style array language;

fast execution in interpreted mode (with a translator to C++ in the works);

a full suite of linear algebra tools;

a full set of fast Fourier transform routines;

running UNIX system commands from within Tela;

working with files in HDF, NetCDF, ASCII, Matlab, and PBM formats; and

several built-in numerical analysis routines, e.g. linear interpolation, integration, root finding, nonlinear fitting, etc.

The graphics capabilities, accomplished via a linkage with a separate program Plotmtv, include 2-D and 3-D line and curve, contour, density, vector field, and surface plots as well as bar charts and histograms. Plots and be overlaid and stacked and saved in PostScript or GIF format.
Tela is written in C++ and has been compiled on SGI, Linux, Sun, Cray, IBM, HP, Sun and DEC platforms. The available source code can be compiled usingGCC/G++ and also with some native C++ compilers. Binaries are available for Cray, HP, IBM, Linux, SGI and Sun machines. Documentation includes a user's guide in PostScript format as well as online help files, man pages and some selected PlotMTV documentation.
[http://sumppu.fmi.fi/prog/tela.html]
telephony: Software for using telephones over the Internet includes:

ACS, a project to develop an extensible C++ class to implement a commercial quality multi-line communications server;

Asterisk, a PBX and telephony toolkit;

Bayonne, a multi-line voice response telephony server;

DBS Server, integrates the Panasonic DBS telephone system with UNIX servers;

Ethernet Phone, provides real time point-to-point voice communications via the Internet;

Free Phone, an audio tool for the Internet;

H.323, a protocol used for Internet telephony;

Linux Phone Project, a project for sending digital voice using 4800 bps modems;

mvm, a modem-independent voice mail system;

Nautilus, a program for holding secure voice conversations over modems or TCP/IP;

mgcp, an implementation of the MGCP protocol stack;

MGCP, a protocol for controlling Voice over IP (i.e. telephony) gateways;

Nautilus, a program for encrypting voice telephone conversations;

OpenH323, an H.323 protocol stack for Linux;

Open Telecom, software for computer telephony that specifically focuses on the hot-swap and circuit switching capabilities of CompactPCI and H.110 CT Bus systems;

rapd, a daemon that sends text messages to radio pagers and mobile telephones;

Speak Freely, an internet telephone program;

vbox, a voice message box written for isdn4linux;

vgetty, turns a modem into an answering machine;

VOCP, a complete voice messaging solution; and

WAP, a collection of protocols for working across wireless network technologies.

[http://www.linuxtelephony.org/]
TeleSoft: A simulator for studying network design problems whose features include:

visualization of network state evolution in real-time with the display of different abstractions of the state;

the interactive modification of most control, configuration and environmental parameters at run-time; and

large computational rsources with low-latency interaction.

A source code distribution of this C++ package is available which has been successfully implemented on several platforms including Linux Intel. A user's manual is available in HTML and PostScript format.
[http://comet.ctr.columbia.edu/software/TeleSoft/]
Telnet98: A new release of the classic telnet program which adds some new features including a configure-based build and install system, support for additional authentication and encryption types, and miscellaneous bugfixes. A source code distribution is available.
[ftp://quasimodo.stanford.edu/pub/telnet/]
Template Numerical Toolkit: TNT is a collection of mathematical libraries for numeric computation in C++. Its fundamental classes include vectors, matrices, and multidimensional arrays with the basic idea being to allow mathematical computations to be expressed at a higher level of abstraction while retaining some control over performance and optimization issues. This is a planned successor to the LAPACK++, SparseLib++, IML++ and MV++ packages. The goal is to formally integrate these packages into a generic algorithm library that supports generic user-defined data types to increase its functionality, and also to take advantage of the latest features in the ANSI C++ specification such as the STL which were not available for the earlier packages.
The features that separate TNT from previous libraries include:

matrix and vector classes of arbitrary types,

high-level algorithms which are expressed independent of matrix/vector type,

template-based algorithms which support generic type matrices,

more powerful sparse matrix operations and integration with a generic-level Sparse BLAS interface,

more powerful sparse matrix indexing,

block indexing for dense matrices and vectors, and

a large set of matrix variations including symmetric, Hermitian, and skew symmetric.

TNT provides several different implementation choices for the basic data structures. It supports four different variations of sparse vectors, a linked-list implementation, a vector-based implementation, a balanced-tree implementation, and a Fortran-compatible implementation which provides compatible data structures for external libraries and legacy codes.
The TNT library is currently (6/97) still under development with source code versions available. It is being developed on UNIX platforms using g++ 2.7.2 and requires that a version of STL be separately compiled and installed. Documentation is available in the form of some technical reports in HTML or PostScript format.
[http://math.nist.gov/tnt/]
Templates: A set of packages and a book on templates, or algorithmic descriptions, for the solution of linear algebra problems using iterative methods. The templates are displayed in the book in an Algol-like structure which is readily translatable into a target language such as Fortran or C. Each template contains some or all of the following: a mathematical description of the flow of the iteration, a discussion of convergence and stopping criteria, suggestion for application to special matrix types, advice for tuning, tips on parallel implementation, and hints as to just when to use a particular method.
The packages and book cover: stationary iterative methods such as the Jacobi method, the Gauss-Seidel method, and successive and symmetric successive overrelaxation methods; nonstationary iterative methods such a the conjugate gradient (CG) method, MINRES and SYMMLQ, CG on the normal equations, generalize minimal residual (GMRES), biconjugate gradient (BiCG), quasi-minimal residual (QMR), conjugate gradient squared (CGS), and Chebyshev iteration; and various Krylov methods. Various preconditioning methods are also covered, e.g. Jacobi, SSOR, incomplete factorization, and polynomial preconditioners. Other topics such as complex systems, stopping criteria, data structures, parallelism, domain decomposition methods, and multigrid methods.
The algorithms in the book are available in separate packages containing Matlab, Fortran (single and double precision), C, and C++ source code versions. The book itself can be bought from SIAM but is also freely available in either PostScript or HTML format.
[http://www.netlib.org/templates/]
TenDRA: A free C/C++ compiler and checker technology developed around the TDF/ANDF compiler intermediate format. TenDRA is the name of the compiler technology built around the TDF intermediate language. A flexible and clean compiler technology is produced via the combination of the rigid enforcement of an interface level between the compiler front-ends and back-ends and the goal of producing target independent TDF suitable for distribution. TDF or TenDRA Distribution Format is the compiler intermediate language which is an abstraction of high level rather than assembly languages. It is the technology adopted by OSF as their ANDF (Architecture Neutral Distribution Format).
The TenDRA compiler consists of two main user interfaces:

tcc, which can be used as a direct replacement for the system C compiler; and

tchk, which is like a version of lint and just applies the static program checks while disabling code generation.

There are two tools for compiling high-level languages to TDF (called producers):

tdfc, a producer for C; and

tcpplus, a producer for C++.

There are several tools (called installers) for compiling the resulting TDF into machine languages, including one for Linux Intel platforms. Each installer consists of code from three levels:

code common to all installers;

code specific to a particular processor; and

code specific to a particular processor/operating system pair.

Other TDF tools included in the TenDRA package include:

tspec, which implements the API checking facilities of the compiler by generating abstract interface specifications;

tld, a TDF linker that combines a number of TDF capsules into a single capsule;

disp, a pretty printer that translates the bitstream comprising a TDF capsule into human readable form;

tnc, a TDF notation compiler that acts as a sort of TDF assembler to translate TDF capsules to and from human readable form;

pl, a PL_TDF compiler that acts as a TDF structured assembler;

sid, an LL(1) parser generator;

calculus, a tool for managing complex C type systems; and

make_tdf, a tool for generating TDF decoders and encoders.

A source code distribution of TenDRA is available. Quite a bit of documentation is available for the bits and pieces comprising the package, although a coherent overview seems to be lacking.
[http://www.cse.unsw.edu.au/~patrykz/TenDRA/]
[http://members.nbci.com/tendra/]
TENMIN: A package for finding the unconstrained minimizer of a nonlinear function of n variables. It is intended for problems where n is 100 or less. The user can choose between a recently developed tensor method or a standard method based upon a quadratic model. This package is written in Fortran, and a user's guide is available. This is TOMS algorithm 765 and is documented in Bouaricha (1997).
[ftp://ftp.cs.colorado.edu/pub/cs/distribs/tensor/]
TENPACK: A LAPACK-based library for the computer manipulation of tensor products. The routines in the package include:

TPMULT, multiplies a tensor product matrix and a vector;

TMPFACT, replaces the components of a matrix with their LU factorization; and

TPSOLV, solves linear equations when the matrix of a system is a tensor product.

Several other routines are also included for performing various subtasks. This is TOMS algorithm 753 and is documented in Buis and Dyksen (1996b) and Buis and Dyksen (1996a).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
TENSBS: A package of Fortran 77 routines for the interpolation of 2- and 3-D gridded data using tensor products of B-spline basis functions. The subroutines in the package are: B2INK, which computes parameters which define a piecewise polynomial function that interpolates a given set of 2-D gridded data; B2VAL, which evaluates the interpolating function determined by B2INK or one of its derivatives; B3INK, similar to B2INK for 3-D gridded data; and B3VAL, similar to B2VAL for 3-D gridded data.
A source code distribution of TENSBS is available. It is written in Fortran 77 and 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/]
TENSOLVE: A modular software package for solving systems of nonlinear equations and nonlinear least squares problems using a new class of methods called tensor methods. This package, originally called TENSPACK, is intended for small to medium sized problems with up to 100 equations and unknowns. It is written in Fortran and a user's guide is available. This is TOMS algorithm 768 and is documented in Bouaricha and Schnabel (1997).
[ftp://ftp.cs.colorado.edu/pub/cs/distribs/tensor/]
TENSRD: A package for finding the unconstrained minimizer of a nonlinear function of N variables. This is intended for problems with N somewhere around 100 so the cost of storing and factoring an NxN matrix at each iteration is acceptable. A choice is given between a tensor method for unconstrained optimization and an analogous standard method based on a quadratic model. The tensor method bases each iteration on a specially constructed fourth-order model of the objective function, and generally requires significantly fewer iterations and function evaluations than does the standard method. It can also solve a moderately wider range of problems. This is TOMS algorithm 739 and is documented in Chow et al. (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
TEQUAD: A Fortran 77 package implementing a new representation of Patterson's quadrature formulae. This is TOMS algorithm 699 and is documented in Krogh and Van Snyder (1991).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
termcap/terminfo: A library of C functions that enable programs to send control strings to terminals in a manner that is independent of the terminal type. The GNU termcap library doesn't place any limits on the size of termcap entries. The termcap data base describes the capabilities of hundreds of different display terminals in excruciating detail, and the library provides easy access to this data base. Most of this package is distributed with Emacs, but this has been made available for those who want a separate libtermcap. The GNU folks are currently (9/97) discouraging the use of this as it is being phased out in favor of the terminfo-based ncurses library which contains an emulation of the termcap library as well as a curses implementation. See Strang et al. (1988).
[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://tuxedo.org/~esr/terminfo/]
terminal emulation: Software that emulates hardware terminals or that is otherwise related to setting up terminals. Listed packages include:

aterm

C-Kermit;

Eterm

GemVt

Gsh

kvt, part of KDE;

9term;

PowerShell, a terminal emulator supporting many terminals embedded into a single window via tabs;

rxvt;

termcap;

terminfo;

tn5250;

virt;

xtermset

x3270.
terminfo: See termcap.
Test Matrix Toolbox: A Matlab toolbox containing a collection of test matrices, routines for visualizing matrices, routines for direct search optimization, and miscellaneous routines which provide useful additions to Matlab's existing set of functions. Test matrices are an indispensable part of performing numerical experiments in matrix computations. Matrices with known solutions and properties can be used to compare rival methods with regard to accuracy, speed, and reliability; to verify the correctness of an algorithm; and to tune parameters in an algorithm.
The Toolbox contains 59 parameterized test matrices, most of which are square, dense, nonrandom, and of arbitrary dimension. These include matrices with known inverses or eigenvalues, ill-conditioned or rank deficient matrices, and symmetric, positive-definite, orthogonal, defective, involutary, and totally positive matrices. The visualization routines display surface plots of a matrix and its inverse, the field of values, Gershgorin disks, and 2- and 3-D views of pseudospectra. The direct search routines implement the alternating directions method, the multi-directional search method, and the Nelder-Mead simplex method.
The Toolkit can be used with Matlab or with the freely available Octave package which can run most Matlab m-files. It is extensively documented in a 70 page user's and reference manual in PostScript format. See Higham (1996).
[ftp://ftp.mathworks.com/pub/contrib/v4/linalg/]
TET: The Test Environment Toolkit is a universal management and reporting framework for automated testing. It provides an standard API between the test code and the overall test process, and has been used in automated testing applications ranging from standards API conformance testing to performance and stress testing to verification of secure electronic transactions to distributed cross-platform applications. TET was collaboratively developed by OSF, UNIX International and X/Open. TET consists of three basic components:

a test case controller;

a generic test suite and test case structure; and

various programmatic interfaces for use in the development of test cases.

The features of the TET implementation include:

support for assertion-based testing;

building, executing and cleaning up test suites;

allowing testing to be defined in terms of scenarios via an expressive scenario language, i.e. the capability of reusing existing tests for different purposes;

parameterizing tests via a flexible configuration mechanism; and

built-in support for POSIX 1003.3 result codes with the capability of adding user-defined result codes;

executing test cases distributed as binary executables;

extension of the base set of result codes with test suite specific sets; and

output of a journal file in standard format for the generation of reports.

These allow the execution of tests in several modes including:

execution of non-distributed test cases on a local system;

execution of non-distributed test cases on one or more remote systems;

execution of distributed test cases with the parts of each test case executing simultaneously on either the local system and one or more remote systems, or entirely on two or more remote systems;

execution of a single test case selected at random from a list of test cases;

combinations of the above executing in parallel; and

sequences of the above executing a specified number of times or until some time period has expired.

The most recent (5/99) version is TET3, a freely available version of the non-free, supported TETware Release 3. TET3 combines the features of previous variants such as TET1.10, ETET and DTET in a portable and consistent implementation. It includes APIs for C, C++, Perl, XPG3 Shell, ksh, Tcl and Java. A whomping big load of documentation is available in various formats.
[http://tetworks.opengroup.org/]
teTeX: A large TeX distribution which includes LaTeX, METAFONT, dvips, xdvi, and many other useful programs. The goal of this package is to make using TeX from within UNIX as easy as possible. This is the TeX distribution I use and I am well pleased with it. I recommend this to anyone who wants to use TeX on a UNIX platform. It's easy to install, use, maintain, and modify, and contains just about everything you'd ever need.
The features of teTeX include:

usabilility on most UNIX platforms, with pre-compiled binaries available for most;

full compile-time independence, i.e. it can be installed in any directory in the system with no need to set any environment variables;

installation and maintenance utilities which ease both of these chores;

very fast file searching via the use of the Kpathsea library, an important feature given the number of ancillary directories in a reasonably complete TeX distribution;

a large collection of ready-to-use font families including cm, dc, charter, oldgerman, ams, pandora, adobe, etc.;

the capability of using the standard PostScript fonts, even with the xdvi viewer;

the latest version of LaTeX, i.e. LaTeX2e; and

a large amount of useful documentation in both TeX and HTML formats.

The teTeX distribution is split into two series, a Base and a Goodies series. The Base series contains everything needed to handle common TeX tasks, i.e. compiling, previewing, conversion to PostScript, etc. The are Base series distributions for several UNIX platforms which contain binary versions of all of the programs. The Goodies series contains additional dvi drivers, much documentation, and several additional fonts. The combination of both series allows the user to accomplish just about anything that can be accomplished with TeX. The is also a Source series available which allows the use to compile the sources, which is useful for either porting to a platform without a Base distribution or recompiling on a supported platform to extend an internal limit which has been exceeded.
The programs in the distribution include:

afm2tfm, for converting Adobe font metrics to TeX font metrics;

allcm, forces the most important Computer Modern fonts to be calculated;

alldc, forces the most important DC fonts to be calculated;

allneeded, forces the calculation of all needed fonts;

append_db, add a single entry to the TeX input files database;

bibtex, compile a bibliography for TeX/LaTeX;

dialog, for displaying dialog boxes from shell scripts;

dmp, converts ditroff output by mpto back to MetaPost;

dvi2fax, converts DVI files into FAX format files;

dvihp, translates DVI files into HP PCL files;

dvilj, translates DVI files into HP LaserJet files;

dvips, translates DVI files into PostScript files;

dvitomp, translates DVI files into MPX files;

dvitype, translates a DVI file to human readable form;

fontexport, exports fonts from the teTeX directory structure;

fontimport, imports fonts into the teTeX directory structure;

gftodvi, converts generic font file output to DVI;

gftopk, converts generic font file output to a packed font file;

gftype, converts a generic font file to human readable form;

gsftopk, calls Ghostscript to render a font at a given resolution;

inimf, invokes Metafont to precompile macros into base files;

inimp, invokes MetaPost to precompile macros into base files;

initex, the TeX program with no preloaded macro packages which converts macro packages into special preformatted binary files;

latex, for translating LaTeX source files into DVI;

mag, computes fontsizes and magsteps;

makeindex, a formatter--independent index processor;

makeinfo, translates Texinfo source into a format for reading with GNU Info;

mf, invokes Metafont to produce font raster and metric files;

mft, translates Metafont code into TeX code for prettyprinting;

mp, invokes MetaPost to produce PostScript output;

patgen, generates patterns for TeX hyphenation;

pfb2pfa, converts type1 pfb files into pfa files;

pk2bm, creates a bitmap from a TeX pkfont;

pktogf, converts packed font files to generic font files;

pktype, translates packed font files to human readable format;

pltotf, converts property list files to TeX font metric format;

pooltype, displays a WEB pool file in human readable format;

ps2pk, creates a TeX pkfont from a type1 PostScript font;;

tangle, translates WEB source into a Pascal program;

tex, invokes TeX to convert TeX source into DVI;

texconfig, configures teTeX;

texhash, rebuilts the TeX input files database;

texi2dvi, translates Texinfo source into DVI;

texi2html, translates Texinfo source into HTML;

texindex, generates a sorted index for each TeX output file;

tftopl, converts TeX font metric files to property lists;

vftovp, converts virtual font files to virtual property lists;

virtex, a version of the TeX program with no preloaded macro packages which can load preformatted binary files produced by initex;

vptovf, converts virtual property lists to virtual font metrics;

weave, translates WEB files to TeX; and

xdvi, a DVI previewer for X11.

The teTeX distribution is available in either source or binary format as explained above. External packages needed to realize the full capabilities of the distribution include the X Window system and Ghostscript.
[http://www.tug.org/teTeX/]
[http://www.ibiblio.org/pub/Linux/apps/tex/teTeX/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/tex/teTeX/]
[ftp://sunsite.informatik.rwth-aachen.de/pub/comp/tex/teTeX]
TeX: An advanced typsetting system that is portable to just about every kind of computer system. TeX is a typesetting language that is used by embedding typesetting commands in plain text files that tell the TeX processor what kind of fonts to use, how wide and high to make the text, how to space between lines and letters, and various other details. The processor then produces and device independent (*.dvi) file that is further translated into the language of whatever device on which it is to be printed. The easiest way to obtain TeX is via an integrated distribution like teTeX, but if you're looking for bits and pieces your best bet is to try the sites offering searching and browsing capabilities, e.g.

CTAN (Comprehensive TeX Archive Network)
[http://www.ctan.org/]

TeX Catalogue Online
[http://theory.uwinnipeg.ca/search/cat/catalogue.html]

Other interesting and informative sites include:

TeX FAQ
[http://www.cogs.susx.ac.uk/cgi-bin/texfaq2html]

TUG (TeX Users Group)
[http://www.tug.org/]

Omega Project
[http://www.ens.fr/omega/]

The original documentation as written by the author Donald Knuth is available as Knuth (1984b) or Knuth (1984a), the former being the paperback and the latter the hardback version. The source code for TeX is available as Knuth (1986a). See also the related Knuth (1986b), Knuth (1986c), and Knuth (1986d) by the same author. Documentation by others includes Abrahams et al. (1990), Borde (1992b), Borde (1992a), Clark (1993), Doob (1993), Eijkhout (1992), Gauthier (1984), Grätzer (1993), Gurari (1994a), Gurari (1994b), Hoenig (1997), Lucarella (1985), Sawyer and Krantz (1995), Seroul and Levy (1991), Snow (1992), Spivak (1990), von Bechtolsheim (1993a), von Bechtolsheim (1993b), von Bechtolsheim (1993c), von Bechtolsheim (1993d), Vulis (1992), and Walsh (1994).
Several GUI interfaces to Tex and/or LaTeX have been developed including:

Ktexmaker, a LaTeX source editor and TeX shell for KDE2

lyx, a word processing environment that creates LaTeX source files

Several macro packages designed either for special applications or to be easier to use have been built on top of TeX including:

INRSTeX,

LaTeX,

Lollipop,

MusicTeX,

MusiXTeX,

PHYS-TeX,

PHYZZX,

StarTeX,

Texinfo, and

TeXsis.

Quite a few programs have been created for converting documents containing TeX, LaTeX or BibTeX into other formats (e.g. HTML and PDF) including:

bibtex2html, from BibTeX to HTML;

bib2html, from BibTeX to HTML;

dvips, from TeX DVI to PostScript;

fbib, for converting bibliographies from BibTeX to FrameMaker format;

GELLMU, from GELLMU format to LaTeX and HTML;

HEVEA, from LaTeX to HTML;

HTeX, from LaTeX math to HTML;

Hyperlatex, from Hyperlatex to LaTeX and HTML;

HyperTeX, for including hyperlink information in TeX and LaTeX;

la_mml, translates LaTeX source into FrameMaker MML format

LaTeX2HTML, from LaTeX to HTML;

LaTeX2hyp, from LaTeX to formatted ASCII;

LA2MML, from LaTeX to Framemaker MML;

Ltoh, from LaTeX to HTML;

mif_la, from FrameMaker MIF to LaTeX;

pdftex, from TeX to PDF;

TeX4ht, from TeX and LaTeX to HTML;

texi2roff, from Texinfo to nroff;

texi2html, from Texinfo to HTML;

tex2html, from TeX to HTML;

tex2gif, from TeX equations to GIFs;

tex2html, from TeX to HTML;

tex2pdf, from TeX to PDF;

Tex2RTF, from TeX to RTF and HTML;

tth, from TeX to HTML;

vulcanize, a subset of LaTeX to HTML.

[ftp://ftp.cdrom.com/pub/tex/ctan/]
[ftp://ftp.tex.ac.uk/tex-archive/]
[ftp://ftp.dante.de/tex-archive/]
TeX4ht: A highly configurable TeX-based authoring system for hypertext which comes with a built-in default setting for plain TeX and LaTeX. TeX4ht consists of many commands and the objective is to provide a friendly programming environment for users at different levels of sophistication.
The capabilities of TeX4ht include:

the conversion of TeX and LaTeX tables to HTML tables,

cross links between the pages of hierarchical documents,

the inclusion of raw HTML code, default HTML output for LaTeX list environments,

the creation of tables of contents,

user-defined sectioning commands,

the inclusion of both mathematics and figures into HTML documents, and

the inclusion of JavaScript.

The TeX4ht source code can be configured and installed on MS-DOS and UNIX systems. The documentation is currently (4/97) online although a hardcopy user's manual is being developed. See also Hyperlatex, HyperTeX, LaTeX2HTML, Ltoh, tex2pdf, Tex2RTF, and tth.
[http://www.cis.ohio-state.edu/~gurari/TeX4ht/mn.html]
Texinfo: A documentation system that uses a single source file to produce both on-line and printable documentation. Thus only one document needs to maintained and updated to keep both form of documentation current. The printed document can have all the features of a book (e.g. chapters, sections, etc.). The on-line documentation is a menu-driven file with nodes, menus, cross-references and indices. The printed document is processed with the TeX formatting system and the on-line version with either the included ``makeinfo'' utility or from within Emacs. Texinfo is the official documentation system used by the FSF's GNU project.
The source code is available for Texinfo as is typical for all GNU projects. It is configured via a script created by the autoconfig utility and compiled using an ANSI-C compiler. As such it is portable to a wide range of platforms. The documentation is contained within, believe it or not, a Texinfo document and can thus be printed or viewed online. The printed version runs to 239 pages in its current (7/96) incarnation. There are at least two programs currently available to translate Texinfo files in standard HTML and thus make them readable via standard hypertext browsers, making a third document format possibility.
[http://www.texinfo.org/]
texi2html: A Perl script which translates Texinfo source files in HTML. Additional features include:

capability of using latex2html;

customizable navigation panels;

on-demand loading of an initialization file in which customizations can be defined;

generation of a short table of contents; and

a customizable footer.

[http://www.mathematik.uni-kl.de/~obachman/Texi2html/]
[http://wwwinfo.cern.ch/dis/texi2html/]
[ftp://ftp.cs.umb.edu/pub/tex/texi2html]
texi2roff: A program to convert Texinfo source code into nroff code.
[http://www.texinfo.org/texi2roff/]
[http://www.tex.ac.uk/tex-archive/support/texi2roff/]
TeXPerfect: A WordPerfect to LaTeX conversion program.
[ftp://ftp.dante.de/tex-archive/support/texperf/]
TeXProject: A LaTeX tool for managing project manuals. TeXProject features: a declarative description language for projects in terms of subprojects, tasks, and milestones; a programmable formatted output of project components such as dates, manpower, descriptions, or dependencies; and an extensible graphical output of schedule, tree, and effort charts for visualizing the project data.
The source code for TeXProject is available in the form of a LaTeX style file, and is it documented in a user's manual available in LaTeX and PostScript formats.
[http://www.cis.ohio-state.edu/~gurari/index3.html]
TeXsis: A collection of TeX macros for typesetting physics documents such as papers, preprints, conference proceedings, books, theses, referee reports, letters, and memos. It has predefined layouts for all of these types of documents and supports a wide variety of type sizes. There are macros for the automatic numbering of equations, automatic numbering and formatting references, double column formats, several special document layouts, making tables and figures, and including tables with horizontal and vertical rules.
[http://feynman.physics.lsa.umich.edu/~myers/texsis/]
[http://tug2.cs.umb.edu/ctan/tex-archive/macros/texsis/]
text markup: A package that transforms text with embedded structural commands (e.g. paragraph, title, section, appendix, index, etc.) into a form that can be further processed by a typesetting package to create a printable document. The former takes a text file with embedded structural commands and produces an output file with structural and more detailed information such as which fonts to use, how wide to make the page, how to number the sections, etc. For example, an SGML processor might take a source code file and produce a TeX source code file which can be further processed by that system.
Test markup packages or systems include:

CoST, an SGML post-processing tool;

DSSSL, a standard for associating preprocessing with SGML documents;

HTML, the markup language of the Web;

InfoPrism, a document processing system that translates SGML into several different output formats;

LaTeX, a markup macro package built on top of TeX;

MathSpad, a general purpose structure editor useful for documents containing mathematical calculations;

MtSgmlQL, a interpreter for the SGML query language SgmlQL;

perlSGML, a collection of Perl software for processing SGML DTDs and documents;

rotfl, a simple text formatter;

SDF, a document development system that generates output in a variety of formats;

SGML, a general markup language;

SGML-Tools, a formatting package that can produce several different formats from a single source file;

sdc, a system that aims to make SGML suitable for everyday use;

SP, an object-oriented toolkit for SGML parsing and entity management;

STIL, a style sheet language used to build structure-controlled applications;

Texinfo, a documentation system that produces both on-line and printable documentation from a single source file;

UDO, a text format and software that allows the creation of several output formats from a source file;

Unroff, a Scheme-based programmable and extensible troff translator with a back-end for HTML;

WebEQ, a Java program for processing and rendering mathematical notation on Web pages;

xindy, a framework for creating indexes for many kinds of documents;

XML, a dialect or subset of SGML for use on the Web; and

YODL, a pre-document language and tools to convert it to many output formats.
text translation: Tools for transforming machine readable text in one format to another format, e.g. LaTeX into HTML. Available translators include:

AFT, from AFT to HTML and LaTeX;

a2ps, from ASCII to PostScript;

bib2html, from BibTeX to HTML;

catdoc, from Word into ASCII;

Distillery, from PostScript into DSC-conforming PostScript;

dvips, from DVI to PostScript;

emil, between various email formats;

enscript, from ASCII to PostScript;

etset, from prepared etext to ASCII, LaTeX or HTML;

gFONT, from ASCII to GIF;

Ghostsript, from PostScript to several raster graphics formats and PDF;

html2rtf, a astkit program for converting HTML to RTF;

html2latex, from HTML to LaTeX;

Hyperlatex, from LaTeX to HTML;

HyperTeX, from TeX to HTML;

InfoPrism, from SGML to HTML, Texinfo and LaTeX;

LaTeX2HTML, from LaTeX to HTML;

LA2MML, from LaTeX to Framemaker MML;

Latte, from Latte to HTML;

Ltoh, from LaTeX to HTML;

MHonArc, from email to HTML;

mm2html, a astkit program for converting mm/man to HTML;

SIXPACK, from other bibliography styles into BibTeX;

TeX4ht, from TeX and LaTeX to HTML;

texi2html, from Texinfo to HTML;

texi2roff, from Texinfo to nroff;

TeXPerfect, from WordPerfect to LaTeX;

textogif, from LaTeX equations to GIFs;

tex2pdf, from TeX to PDF;

Tex2RTF, from LaTeX to linear RTF, Windows Help hypertext RTF, HTML and XLP wxHelp format;

tofrodos, to and from DOS and UNIX formats;

troffcvt, from troff to HTML, RTF, or plain text;

troff2html, from troff to HTML;

tr2latex, from troff to LaTeX;

tth, from TeX to HTML;

UDO, from UDO to HTML;

unroff, from troff to HTML;

WebEQ, from math into HTML;

word2x, from Word to ASCII, LaTeX and HTML;

xpdf, from PDF to PostScript; and

YODL, from YODL to LaTeX and HTML.
textogif: A Perl program that compiles individual equations in short LaTeX files into GIF images. This is basically the part of LaTeX2HTML that performs the same function extracted for use with smaller projects.
[http://www.fourmilab.ch/webtools/textogif/textogif.html]
tex2html: A Scheme script that converts plain TeX documents into HTML. This will run on several Scheme dialects and even a couple of Common Lisp distributions. A source code distribution is available.
[http://www.cs.rice.edu/~dorai/tex2html/tex2html.html]
tex2pdf: An extension of TeX which can be used to create PDF documents from TeX.
The tex2pdf package can be obtained as source code or in binary format for Amiga, Linux Intel, SGI IRIX, Sun SunOS and Solaris, and Windows platforms. See also Hyperlatex, HyperTeX, LaTeX2HTML, Ltoh, Tex2RTF, TeX4ht, and tth.
[ftp://ftp.cdrom.com/pub/tex/ctan/systems/tex2pdf/]
[http://www.ibiblio.org/pub/packages/TeX/systems/tex2pdf/]
TextTools: A Java package providing powerful awk-like line by line processing with pattern action pairs. It provides a set of pattern caching classes to keep track of compiled regular expressions. It also includes a glob pattern compiler and a set of regular expression FilenameFilter implementations to make filename matching tasks easier.
A source code implementation of TextTools is freely available under the terms of a non-exclusive, non-transferable limited license whose details are available at the site. This