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 requires the related OROMatcher package. The API is documented in HTML format.
[http://www.oroinc.com/]
TeX2RTF: A utility which converts LaTeX into four other formats: linear RTF for importation into a wide variety of word processors, Windows Help hypertext RTF (for compilation with the Help Compiler), HTML, and XLP wxHelp format. It parses a subset of LaTeX which does not include tables, the tabbing environment, and equations.
Tex2RTF is written in C++ using the wxWindows class library. It requires this package as well as Motif for installation of the source code on UNIX platforms. A user's manual is included in several formats. See also Hyperlatex, HyperTeX, LaTeX2HTML, Ltoh, tex2pdf, TeX4ht, and tth.
[http://web.ukonline.co.uk/julian.smart/tex2rtf/]
textutils: The GNU versions of various text processing utilities found on UNIX systems. The programs include:

cat, for concatenating and writing files;

tact, for reversing files;

nl, for numbering lines and writing files;

od, for dumping files in octal format;

fmt, for reformatting paragraph text;

pr, for paginating or columnating lines;

fold, for wrapping long input lines;

head and tail, for outputting the first and last parts of files;

split and csplit, for splitting files into fixed size pieces or by context;

wc, for counting words or lines;

sum and cksum, for printing traditional or POSIX CRC checksums;

sort, for sorting text files;

uniq, for uniqifying files;

comm, for comparing sorted files by line;

cut, for printing selected parts of lines;

paste, for merging lines of files;

join, for joining lines on a common field;

tr, for translating characters;

expand, for converting tabs to spaces; and

unexpand, for converting spaces to tabs.

A source code distribution of textutils is available. All programs are written in ANSI C and can be compiled on most platforms via the supplied configure and make files. The programs are documented in Texinfo format.
[http://www.gnu.org/software/textutils/textutils.html]
TFTB: The Time Frequency ToolBox is a collection of around 100 Matlab files developed for the analysis of non-stationary signals using time-frequency distributions. It consists of groups of signal generation, processing, and post-processing files and also includes visualization tools. Numerous time-frequency signal analysis algorithms are included. TFTB is documented in a reference manual and a tutorial, both of which are available in PostScript format.
[http://crttsn.univ-nantes.fr/~auger/tftbftp.html]
[http://www.aei-potsdam.mpg.de/~eric/tftb/tftb.html]
TFTP: The Trivial File Transfer Protocol is a simple protocol for transferring files implemented on top of UDP. It can be used to read and write files, but lacks the other features of regular FTP such as listing directories. It is most recently described in RFC 1350.
tgif: An Xlib-based 2-D drawing facility under X11 which supports the hierarchical construction of drawings and easy navigation between sets of drawings. It is also a hyper-structured-graphics editor/browser for the Web, i.e. it can be used to create or view a drawing containing primitive graphical objects. Supported objects include rectangles, ovals, rounded-corner rectangles, arcs, polylines, polygons, open-splines, closed-splines, text, X11 bitmaps, some X11 pixmaps, and encapsulated PostScript (EPS). Objects can be grouped together to form a grouped objects which can be made into an icon or symbol object.
All objects in Tgif can be moved, duplicated, deleted, rotated, flipped, and sheared. There is support for 32 fill patterns, 32 pen patterns, 7 default line widths, 4 line styles, 9 dash patterns, 3 types of text justification, 4 text styles, 11 default text sizes, 5 default fonts, and 11 default colors. Additional line widths, text sizes, and fonts can be added. Most commands can be activated via either a pop-up window or a keyboard sequence. Tgif can generate output in PostScript, EPS, X11 bitmap, and X11 pixmap formats. It can import X11 bitmap, some X11 pixmap, GIF, and EPS files and represent the contents as primitive objects.
The source code is available and should install easily on generic UNIX/X11 platforms. The documentation is contained within a man page for which a PostScript version is available.
[http://bourbon.cs.umd.edu:8001/tgif/]
THE: The Hessling Editor is a text editor modeled on the VM/CMS text editor XEDIT which also includes features from Mansfield Software's Kedit for DOS. It uses REXX as a macro language which makes it highly configurable and versatile.
[http://www.lightlink.com/hessling/THE/]
ThisForth: This calls itself a reluctantly ANS-compliant C-Forth. It was originally developed as an embedded command line interpreter and scripting tool for UNIX applications. It uses Standard C and the Standard C library for portability and extensibility, and the m4 macro preprocessor to define primitives in low level Forth. It is available as source code or in binary format for several architectures including Linux Intel.
[ftp://ftp.forth.org//pub/Forth/Compilers/native/unix/]
[http://www.taygeta.com/forthcomp.html]
Thomas: A compiler that compiles a language compatible with the language called Dylan. This distribution is written in Scheme and is compatible with MIT Scheme, DEC's Scheme-C, and gambit. The documentation is sparse.
[ftp://swiss-ftp.ai.mit.edu/pub/Thomas/]
Thot: A structured document editor offering a graphical WYSIWIG interface under X11. A large set of advanced tools like a spell checker are built-in, and it can export documents to common formats like HTML and LaTeX.
[http://www.inrialpes.fr/opera/]
[http://www.ibiblio.org/pub/Linux/apps/editors/X/thot/]
ThoughtTreasure: A comprehensive platform for natural language processing (NLP) and common sense reasoning. ThoughtTreasure can allow an application to obtain answers to questions easily answered by humans but previously quite difficult for computers to answer. It contains a database of 20,000 concepts organized into a hierarchy with each concept having one or more English and French approximate synonyms for a total of about 50,000 words and phrases. It also contains 14,000 assertions about concepts. The program, written in C, implements:

text agents for recognizing words, phrases, names and phone numbers;

mechanisms for learning new words;

a syntactic parser;

a natural language generator;

a semantic parser for producing a surface-level understanding of a sentence;

an anaphoric parser for resolving pronouns;

planning agents for achieving goals on behalf of simulated actors; and

understanding agents for producing a more detailed understanding of a discourse.

Full documentation can be found in Mueller (1998).
[http://www.signiform.com/tt/htm/tt.htm]
threads: Threads are related to UNIX processes although they are not processes themselves. A process contains both an executing program and a set of resources such as a file descriptor table and address space. A thread handles execution activities, i.e. it is essentially a program counter, a stack, and a set of registers, with the other resources contained in a separate entity sometimes called a task. A task can be associated with any number of threads, and all threads must be associated with some task. Threads are smaller than processes and therefore relatively cheap in terms of CPU time. They also require less memory. A thread can be thought of as a sequential flow of control through a program, with multi-threaded programming a form of parallel programming where several threads are concurrently executing in a program. All of the threads execute in the same memeory space and can thus work concurrently on shared data. Threads are useful for allowing a program to exploit multi-processor machines where they can run in parallel on several processors and allow a significant speed-up over a single processor. They are also useful for programs that are best expressed as several threads of control that intercommunicate, with examples including server programs and graphical user interfaces.
The first implementations of threads were proprietary libraries such as Mach cthreads, Solaris threads, and IRIX sprocs. These are mostly being replaced by implementations of POSIX B 1003.1c, a standard API for multi-threaded programming. The ultimate goal is to have multi-threaded programs run unchanged on all UNIX platforms.
Threads packages available for Linux platforms include:

APE,

Cthreads,

FSU Pthreads,

Hood, a user-level threads library for multiprogrammed multiprocessors;

LinuxThreads,

NPS,

OpenThreads,

PCthreads,

Pthreads,

QpThread, a C++ thread library that provides an object-oriented framework on top of system level threads

QuickThreads,

RT++,

SMARTS and

TThread.

Applications which use threads include: ACE, AOLserver, Arachne, AXIS, C++SIM, Converse, CVM, DOME, Dynace, EuLisp, ILU, lil-gp, Mach, Nexus, omniORB, PAMELA, Phantom, phttpd, PPCR, sC++, Shadows, SmartGDB, SMT, TPVM, and Xitami.
See Kleiman et al. (1996), Lewis and Berg (1996), Northrup (1996), Norton (1997), and Prasad (1997).
3dfx: A 3Dfx Banshee/Voodoo3 framebuffer device driver for Linux/x86. This works with 2.2 and 2.3 kernels, and PowerPC support is in the works.
[http://www.hut.fi/~hmallat/linux/3dfx.html]
3dom: A 3-D solid object modeler designed to create scenes for input into rendering programs, e.g. POV-Ray. 3Dom features a mouse-based interface which can be used to manipulation 3-D objects, and a special 3-D scene format which can be converted to and from existing formats. It can take advantage of special graphical display hardware but also includes software emulations when such things are not available. Objects supported by 3Dom include boxes, open and closed cylinders, spheres, cones, toruses, blobs, height fields, polygons, discs, parabolas and hyperbolas, and quadrical surfaces.
Additional 3dom features include:

a solid only modeler;

an abstracted color and chromaticity idea that uses different models (RGB, CIE, etc.) concurrently to represent the same color and allow for perfect adaptation to any global illumination format;

an abstracted material definition idea and separates material properties into surface and body properties;

grouping objects into a hierarchy of aggregates using either a compound (i.e. a combination of multiple non-overlapping objects) or a CSG object (i.e. the union, intersection or difference of various overlapping or non-overlapping objects);

a GUI constructed using the Qt library for accurately manipulating objects using snap-points and grids;

a plugin interface to user-loadable code using shared libraries;

saving and reading in a native file format;

exporting to MGF, POV or RIB;

an infinite undo/redo and repeat stack;

a 2-D editor to create surfaces of revolution; and

integration with RenderPark.

The 3Dom software is available in source code form as well as in binary format for HP-UX, Linux ELF (on Intel and Sparc), Sun Solaris, and SGI IRIX platforms. It is currently documented via an online tutorial at the home site.
[http://www.cs.kuleuven.ac.be/cwis/research/graphics/3DOM/]
[http://threedom.sourceforge.net/]
3SMAC: An a priori seismological model of the upper mantle based on geophysical modeling. The model is constructed in a series of steps, i.e.:

creation and/or modification of files containing the thicknesses of the chemical layers (e.g. topography, sediments, crust, etc.);

choice and/or modification of files controlling the temperature distribution (e.g. oceanic age, shields, slabs, plumes, etc.);

creation and/or modification of parameters for phase transitions; and

choice and/or modification of the seismological parameters to be determined as well as their relationship to temperature and pressure for the various chemistries/mineralogies.

This Fortran 77 packages seems to be readily portable. See Nataf and Ricard (1996) and Ricard et al. (1996).
[http://geoscope.ipgp.jussieu.fr/pub/logiciels/3SMAC]
thttpd: A simple, small, portable, fast and secure HTTP server that handles only the minimum needed to implement HTTP/1.1. One unique feature is URL traffic-based throttling which allows you to set maximum byte rates on URLs or URL groups. A source code distribution is available which can be compiled and installed on generic UNIX platforms with a C compiler.
[http://www.acme.com/software/thttpd/]
THUD: A register transfer level (RTL) simulation environment that has been optimized for cycle-based designs. The designs are expressed in TH, a Scheme-based hardware description language (HDL). Primitives are provided for session management, file format translation, scheduling, and data structure examination and simulation. Translators are included that can read and write a subset of the language used in Verilog. This can be used on both batch and interactive modes. A source code distribution is available which requires Guile 1.3 for compilation and use. A user's manual is available in the usual formats.
[http://www.glug.org/people/ttn/software/thud/]
TIDE: The Tools for the Integration of Differential Equations is a collection of C++ classes for performing numerical computations. It covers a range from ordinary differential equations (ODEs) and adaptive integration methods over nonlinear problems to the discretization of partial differential equations (PDEs) by the finite difference method. It was designed to facilitate the development of numerical applications, especially with regard to modern adaptive algorithms.
The classes are organized in mostly independent modules. These modules are:

general, a class used everywhere in the project such as the main object, smart pointers, list and vector templates, etc.;

ode, a class for ODEs and adaptive extrapolation integrators;

nonlin, a class for nonlinear problems; a bvp class for solving boundary value problems using multiple shooting methods;

fem, a class for performing finite element discretizations and using multigrid methods;

latool, a class providing a LAPACK interface;

special, a class for special functions (which provides an FFTPACK interface); and

parser, a class for formal parsers based on flex and bison.

The TIDE package includes the source code which is written in C++. It was developed using the gcc/g++ compiler so it should be portable to any platform on which the gcc/g++ can be installed. The documentation is contained within various documents in HTML and PostScript format which are included with the distribution package.
[http://elib.zib.de/pub/Packages/code++/]
TIDY: A utility that automatically fixes many errors in HTML source code. Tidy uses heuristic knowledge of how to fix errors to repair a document, with the knowledge based on experience of how common browsers recover from markup errors. It distinguishes two classes of errors: (1) warnings which it can fix by itself and (2) errors for which it is better for the author to fix. There is also limited support for parsing and prettyprinting XML.
The features of TIDY include:

fixing many common errors in HTML markup including missing or mismatched end tags, end tags in the wrong order, problems with heading emphasis, adding the missing slash in endtags, adding missing quotes around attribute values, reporting unknown or proprietary attributes, and reporting proprietary elements;

a choice of layout styles for the cleaned up markup file;

a choice of US ASCII, ISO Latin-1, UTF-8 and ISO 2022 7-bit family character encodings;

advice on accessibility for people using non-graphical browsers;

replacement of excess presentational tags with style properties and rules using CSS;

fixing errors that would cause files to be rejected by XML processors;

a slides option for transforming a single HTML file into a number of linked slides; and

indentation of source for better layout.

A source code distribution of Tidy is available. It is written in ANSI C and can be compiled on UNIX platforms with an appropriate compiler. Documentation is supplied online.
[http://www.w3.org/People/Raggett/tidy/]
TIGER: The Tcl based Interpretative Graphics EnviRRonment is a tool for interpretative graphics programming. It provides a Tcl binding for the OpenGL 1.0 specification wherein each OpenGL function is implemented with an equivalent Tcl command with the same arguments. TIGER also supplies the window and event handling commands lacking in OpenGL via Tcl commands, Tcl commands for mathematical functions, and a Tcl-based interpretative class system for object-oriented programming.
The TIGER system uses the Tcl Tix extensions to allow the development of graphical user interfaces (GUIs) with embedded graphics windows, wherein a graphics window is realized by the Tix Tk widget extensions. The TIGER GUI allows the interactive development of graphical applications and features script editing with a highlighting mode for OpenGL and Tcl commands, evaluation of scripts, viewing OpenGL state variables, and debugging of scripts.
The TIGER package is available for AIX, HP-UX, SGI IRIX, Linux, and SunOS systems. The documentation is contained within man pages and an online help system.
[http://www.EasternGraphics.com/t108037/download.htm]
TIGER (security): A set of Bourne shell scripts, C programs and data files for performing security audits of UNIX systems. The primary goal of TIGER is to report ways in which root can be compromised. The primary assumption made is that any UID other than 0 can be obtained and that any GID can be obtained by unauthorized persons. It performs its taks by checking all paths into root to see if anyone other than root can alter that path, and flags all instances where this can be done. The things checked include cron entries, mail aliases, NFS exports, inetd entries, PATH variables, .rhosts and .netrc files, specific file and directory access permissions, unusual files, binaries and pathnames embedded in any files. A source code distribution is available which has configuration files for several platforms including Linux (although the Linux configuration file is said to be less than complete as compared to some others).
[ftp://net.tamu.edu/pub/security/TAMU/]
Tierra: A program that creates a virtual computer and its Darwinian operating system whose architecture is designed such that the resulting executable machine codes are evolvable. The machine code can be mutated (by flipping bits at random) or recombined (by swapping segments of code between algorithms) with the resulting code remaining functional often enough for natural/artificial selection to be able to improve the code over time. The operating system of the virtual computer provides memory management and timesharing services as well as control over many factors that affect the course of evolution, e.g. three kinds of mutation rates, disturbances, the allocation of CPU time to each creature, the size of the primordial soup, etc. It also provides an elaborate observational system that keeps a record of births and deaths and the code sequences of every creature, maintains a genebank of successful genomes, and automates the recording of the kinds of interactions taking place between creates, i.e. ecological analysis.
The resulting Tierra system produces synthetic organisms based on a computer metaphor of organic life in which CPU time is the energy resource and and memory the material resource. Memory is organized into informational patterns that exploit CPU time for self-replication, mutation generates new forms, and evolution proceeds via natural selection as different genotypes compete for CPU time and memory space. Diverse ecologies have emerged from Tierra simulations and have been used to experimentally examine ecological and evolutionary processes. This is a fairly famous program that has been around and frequently discussed for almost a decade.
Source code and binary distributions of Tierra are available, with a version of the latter available for Linux boxes. Much documentation is also available, including an online user's manual and many technical reports in various formats. A networked Tierra project is underway to use many networked computers to simulate evolutionary processes.
[http://www.hip.atr.co.jp/~ray/tierra/]
TiMBL: The Tilburg Memory Based Learner is a machine learning program that implements a family of memory-based learning techniques. It explicitly stores a representation of training sets in memeory and classifies new cases by extrapolating from the most similar stored cases. Several optional metrics and optimizations that enhance the underlying k-nearest neighbor classifier engine are available including:

information gain weighting for dealing with features of differing importance (i.e. the IB1-IG learning algorithm);

a modified value difference metric for making graded guesses of the match between two different symbolic values;

conversion of the flat distance memory into a decision tree and inverted indexing of the instance memory to yield faster classification; and

additional compression and pruning of the decision tree guided by feature information gain differences.

The package includes an API for accessing its functionality from C++ programs. A source code distribution is available which can be compiled and used on most UNIX flavors. A user's manual in PostScript format is available.
[http://ilk.kub.nl/software.html]
Timbre: A general purpose translation technology whose components are:

a pattern matcher for matching text phrases;

a stack engine for interacting with a computer; and

a rule compiler for defining behavior.

This script-driven translation engine has been used for language translation, target compilation, meta-compiling, code verification, binary viewing, code documentation and RTF parsers and reformatters. Timbre was designed to allow for simple yet powerful ways of translating anything to anything.
A freely available source code distribution includes a Forth to C translator, a user's manual, and several scripts for performing various tasks. Several technical reports dealing with various applications of the package are also available.
[http://www.compusmart.ab.ca/rc/Timbre/timbre.htm]
Timeplt: A collection of Matlab programs (m-files) for Gregorian labeling of stacked time series plots, including vector stick plots. The programs include:

gregaxd, gregaxh, gregaxm, gregaxy which label the current axis with Gregorian labels in units of days, hours, months, and years, respectively;

gregorian, which converts digital Julian days to Gregorian calendar dates;

julian, which converts Gregorian calendar dates into digital Julian days;

timeplot, which creates time series stack plots with Gregorian time labels;

stacklbl, which labels stack plot axes with titles and a y-axis label.

This package can be used with Matlab or with the freely available Octave package which can run most Matlab m-files.
[http://sea-mat.whoi.edu/timeplt-html/]
time series analysis: Packages related to time series analysis include:

ARfit, a Matlab package for the estimation and spectral decomposition of multivariate autoregressive models;

ARTA, for stationary time series with arbitrary marginal distributions and feasible autocorrelation structures specified through the lag;

Coral, programs for analyzing seismic waveform data including several for time series analysis;

DATAPLOT, a huge general data analysis and plotting package which includes time series analysis capabilities;

DSE, programs designed for estimating and converting among various representations of time series models;

Econometrics Toolbox, Matlab functions implementing various econometric estimation methods;

EPIC, an oceanographic data analysis system including time series analysis capabilities;

GMT, a data plotting and analysis package for the geosciences with time series analysis capabilities;

Macanova, a interactive program for general statistical analysis;

MCSSA, Matlab programs for implementing Monte Carlo testing of singular spectrum analysis results;

MSSA, Matlab programs for performing multichannel singular spectrum analysis;

MTM, Matlab programs for implementing multiple taper analysis of time series;

MXENTRP, routines fo.r computing maximum entropy spectral estimates of time series data;

NNSYSID, Matlab programs for neural network based identification of nonlinear dynamic systems;

Ox, a general statistical analysis package with time series analysis capabilities;

PERIOD, for searching for periodicities in data using time series analysis;

PSD, for obtaining power spectral density estimates from time series using the maximum entropy and Welch overlapped segment methods;

Regarima, for analyzing time series using regression models with errors that follow ARIMA models;

RPSstuff, Matlab programs for various time series manipulations and analyses;

SNP, for multivariate nonparametric time series analysis by maximum likelihood polynomial expansion;

SSA-MTM, for time series analysis via correlogram estimation, the multi-taper method, and the maximum entropy method;

STARPAC, a collection of routines for statistical analysis including analysis of time series;

TISEAN, a collection programs for nonlinear time series analysis;

TSP, for analyzing time series and polarimetric data in astronomy;

wavetest, for performing spectral analyses of time series using wavelets

XploRe, a general statistical analysis package with times series capabilities; and

X-12-ARIMA, for seasonally adjusting economic time series, i.e. for fitting regression models with ARIMA errors.
timewarp: A program that allows you to warp the system time returned by the kernel to specific, user-defined processes. This pragmatically allows you to fool a process into thinking that the current time is something other than it is, which in turn allows you to continue running binary software that has ostensibly expired without having to reset the time on the entire system (although neither I nor the author of the software would never recommend doing such a thing). Timewarp is a loadable kernel module available in a source code distribution.
[http://nwc.syr.edu/~jdimpson/proj/]
TiMidity: A MIDI to WAVE converter (MIDI renderer) which uses Gravis Ultrasound-compatible patch files to generate digital audio data from General MIDI files. The audio data can be played through an audio device or stored on disk. A 16-bit audio device is recommended, with the VoxWare sound driver the recommendation for Linux systems.
The features of TiMidity include:

32 or more dynamically allocated fully independent voices;

output to a 16- or 8-bit PCM of uLaw audio device, serer, file or stdout at any sampling rate; an optional interactive mode with a real-time status display under the ncurses and Slang libraries;

an optional Motif or Tcl/Tk interface;

support for the transparent loading of compressed MIDI and patch files;

and support for several MIDI events including program change, key pressure, channel main volume, tempo, panning, a damper pedal, a pitch wheel (with sensitivity), and a change drum set.

The source code to TiMidity, written in C, is available. Compilation on a generic UNIX platform requires a C compiler and, of course, any of the libraries needed for the interfaces mentioned above. Appropriate video hardware is also needed for various platforms.
[http://tcts.fpms.ac.be/~pagel/TIMIDITY/]
[http://www.netspace.net.au/~ggt/timidity.html]
[http://www.goice.co.jp/member/mo/timidity/]
tin: A threaded and spool-based Usenet newsreader.
[http://www.tin.org/]
[http://sunsite.unc.edu/pub/Linux/system/news/readers/]
TINA: A package of libraries developed to simplify the task of vision algorithm development and evaluation. Much effort has gone into integrating general purpose flexibility in regards to user programming in the libraries to allow researchers to develop algorithms rather than a basic support infrastructure. TINA provides a hierarchy of image processing, display, and interactive manipulation modules specifically designed for the recovery and representation of the 2-D and 3-D geometrical primitives required for the development and evaluation of computer vision systems. An extensive mathematics library for the manipulation of image and geometric data structures underlies this hierarchy.
The TINA library separates functions into sub-libraries of three different types. The window system independent graphics libraries include user interface modules, infrastructure modules, and interactive graphics modules, with the interface models being a set of interface tools responsible for managing resources in the TINA infrastructure and controlling the application of various processing modules. The window system specific graphics libraries include:

Tw, a set of TINAWindows tool prototyping libraries which provide a generic subset of standard interactive tools with appropriate callback functions, and

Tvtool, the TINA View Tool device which concentrates all window system specific graphics into a few hundred lines of screen functions code.

The graphics independent libraries include those dealing with file I/O, image and geometry processing, supporting mathematics, and basic system functions. The math libraries include functions for complex and random variables as well as geometry functions for performing 2-D and 3-D vector algebra and geometry, rotations, and transformations. The image processing functions include those for convolution and filtering, pixel processing, noise filtering, image warping, feature location, and much more.
A source code distribution of TINA is available. It is written in ANSI C and has been successfully compiled on Sun SunOS and Solaris, HP-UX, and Linux Intel platforms. It is documented in user's, programmer's, and algorithms guides, all of which are available in both HTML and PostScript format.
[http://www.shef.ac.uk/~eee/esg/compvis/tina.html]
tinc: A Virtual Private Network (VPN) daemon that uses tunneling and encryption to create a secute private network between Internet hosts. The tunnel appears to the IP-level network code as a normal network device, so existing software need not be modified. A single daemon can accept more than one connection at a time, enabling larger virtual networks to be created.
[http://tinc.nl.linux.org/]
TinyDict: A program for direct PostScript processing that typesets ASCII text into various facing page formats for self-printing books on laser printers. This was developed because the author wanted to create self-printing book archives which were independent of commercial software or different operating systems. This creates a script that will automatically paginate ASCII text into library or pocket-book sized facing pages in perfect, wired or punched binding order for printing on a PostScript printer. The capabilities include:

setting text justified left, right, centered, forced or full;

advancing or reversing any whole or fractional distances;

using any available PostScript Type 1 or 3 typeface;

changing font styles, text sizes and line spacing at any time;

automatic text insetting for inline boxes and vertical rules;

setting brochures in 2, 3 or 4 columns;

auto-flowing text from page to page while numbering;

numbering with recto-verso running headers or footers;

inserting folio or roman numbers when making preliminary pages;

tables with calculation facilities;

setting spot-colored text singly or in lines or paragraphs;

creating spot-color circular and rectangular outlines and backgrounds; and

importing and centering EPS files and resizing them as required.

A user's guide is available in PDF format.
[http://www.cappella.demon.co.uk/tinyfiles/tinymenu.html]
TinyLogin: A suite of UNIX utilities for handling logins, authentication, password manipulation, and maintaining users and groups on a small or embedded system. It also provides shadow password support. The programs supported by TinyLogin include adduser, addgroup, deluser, delgroup, login, sulogin, passwd and getty. The BusyBox program is a complement to this for working with small systems.
[http://tinylogin.lineo.com/]
Tiny TeX: A small TeX package on one floppy that contains everything you need to run LaTeX. It comes with fonts, xdvi, dvips, detex, macros and man pages.
[http://sunsite.unc.edu/pub/Linux/apps/tex/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/tex/]
TIP: The Toolkit Interface Protocol is a client/server protocol for remote graphical user interfaces. This differs from the Remote Imaging Protocol (RIP) in that communication between client and server is done on the toolkit rather than the graphics level. The toolkit is defined according to the distinction between Xlib and Xtk which means that client requests concern toolkit objects (i.e. widgets like dialog boxes, buttons, etc.). A TIP client tells its server to create a PushButton, set a label, and a callback whereas an X Window client client would have to create a window, obtain a graphics context, draw borders, fill the button face, draw the shadows, etc. before it can finally draw the text and register some low level events. This leads to benefits such as less communication overhead and full integration of the application into the displaying system's look and feel.
The TIP system is available in binary format for IBM AIX, HP-UX, Linux Intel, MS Windows, and Sun platforms. Documentation is sparse and contained within several ASCII text files. Note: This has disappeared from the given URL. I'd appreciate any information as to its new whereabouts if any.
[ftp://sokrates.ani.univie.ac.at/pub/TIP/]
TIPSY: A package developed to quickly display and analyze the results of N-body simulations in astronomy, i.e. a package designed to display data in particle rather than gridded form. The capabilities include:

displaying particle positions and velocities from an arbitrary viewpoint,

zooming in to a chosen position,

the use of color particles to display scalar fields,

selection of subsets of the data for display,

following selected particles, and

finding cumulative properties of a collection of particles.

As far as I can tell, TIPSY was designed to compile and run on generic UNIX/X11 platforms. TIPSY is part of the HPCCSOFT Tools suite.
[http://www-hpcc.astro.washington.edu/tools/TIPSY/]
TISEAN: A package for nonlinear TIme SEries ANalysis that consists of a couple score of UNIX-style command line programs to perform various tasks. These include programs for generating time series, linear time series methods, utilities, testing for stationarity, embedding and Poincare sections, nonlinear prediction and noise reduction, dimension and entropy estimation, Lyapunov exponents, surrogate data, spike trains and multivariate time series. The programs include:

addnoise, adds Gaussian noise of a given RMS amplitude to a time series;

ar-model, fits a simple autoregressive (AR) model to possibly multivariate data;

ar-run, iterates an autoregressive model;

autocor, computes the autocorrelation or autocovariance of a time series using an FFT for convolution;

av-d2, smooths the output from d2, c1 or c2naive;

boxcount, estimates the Renyi entropy of Qth order using a partition of the phase space instead of the Grassberger-Procaccia scheme;

c1, computes curves for the fixed mass computation of the information dimension;

c2d, computes local slopes from correlation sums;

c2g, computes the Gaussian kernel correlation integral;

c2naive, determines the correlation sums of scalar times series;

c2t, computes a maximum likelihood estimate (Takens' estimator) from correlation sums;

choose, for choosing columns and sub-sequences;

cluster, finds clusters in a dissimilarity matrix;

compare, compares two data sets;

corr, computes the autocorrelation of a scalar data set;

d2, estimates the correlation sum, the correlation dimension and the correlation entropy of a data set;

delay, embeds using delay coordinates;

endtoend, determines the end-to-end mismatch before making surrogate data;

events, converts inter-event intervals to event times;

extrema, determines the maxima/minima of one component of a possibly multivariate time series;

false_nearest, looks for the nearest neighbors of all data points in m dimensions and iterates them one step into the future;

fsle, estimates the finite size Lyapunov exponents;

ghkss, performs a noise reduction via an orthogonal projection onto a q-dimensional manifold using a special metric;

henon, creates Henon map data;

histogram, estimates the scalar distribution of a data set;

intervals, converts event times to inter-event intervals;

ikeda, prints iterates of the Ikeda map;

lazy, performs nonlinear noise reduction with locally constant approximations;

ll-ar, makes a local linear ansatz and estimates the one step prediction error of the model;

low121, applies a simple low pass filter in the time domain;

lyap_k, estimates the largest Lyapunov exponent of a given scalar data set using the algorithm of Kantz;

lyap_r, estimates the largest Lyapunov exponent of a given scalar data set using the algorithm of Rosenstein;

lyap_spec, estimates the whole spectrum of Lyapunov exponents for a given time series;

makenoise, adds a desired amount of noise to a given time series or creates a series of random numbers with zero mean;

mem_spec, estimates the power spectrum of a data set via the maximum entropy principle;

mutual, estimates the time delayed mutual information of a data set;

notch, a simple notch filter in the time domain;

nrlazy, performs simple nonlinear noise reduction;

nstat_z, looks for nonstationarity in a time series;

nstep, creates either a local linear ansatz or a zeroth order ansatz for a time series and iterates an artificial trajectory;

onestep, creates a local linear ansatz and estimates the one step prediction error of the model;

pc, embeds using principal components;

poincare, makes a Poincare section for time continuous scalar data sets along one of the coordinates of the embedding vector;

polyback, performs a backward elimination for a given polynomial;

polypar, creates a parameter file for polynomp and polyback;

polynom, models data making a polynomial ansatz;

polynomp, models data making a polynomial ansatz;

predict, performs locally constant predictions on time series and calculates the RMS prediction error;

project, performs nonlinear projective noise reduction;

randomize, performs general constrained randomization of time series;

randomize_auto, generates surrogates with the same autocorrelation function and distribution as the original data;

randomize_autop, same as the previous except it uses a periodically continued version of the autocorrelation function;

randomize_spikeauto, generates surrogates with the same inter-event interval correlations (or spectrum) and the same distribution of inter-event intervals;

randomize_spikespec, creates an inter-event power spectrum at a given range of frequencies;

randomize_uneven, nonlinearity test for unevenly sampled time series;

rbf, models the data using a radial basis function ansatz;

recurr, produces a recurrence plot of a data set;

resample, resamples data with a new sampling time;

rescale, rescales a time series to a desired interval or to have average zero and/or variance 1;

rms, normalizes a time series and coputes the mean and standard deviation;

sav_gol, performs a Savitzky-Golay filter to clean high frequency noise or to get a better estimate of the Dth derivative;

spectrum, computes a power spectrum by binning adjacent frequencies;

spikeauto, computes the binned autocorrelation function of a series of event times;

spikespec, computes a power spectrum assuming the data are the times of singular events;

stp, computes a space-time separation plot;

surrogates, creates surrogate data with the same Fourier amplitudes and distribution;

svd, performs a global singular value decomposition;

timerev, computes the time reversal asymmetry statistic;

upo, finds unstable orbits and their most unstable eigenvalue;

upoembed, embeds periodic orbits using delay coordinates;

wiener, a Wiener filter;

xc2, computes the cross-correlation integral of two data sets in 2 to M embedding dimensions;

xcor, computes the cross correlations between two time series;

xzero, fits a zeroth order model of one data set to predict a second; and

zeroth, makes a zeroth order ansatz and estimates the one step prediction errors of the model on a multivariate time series.

See (), () and ().
[http://www.mpipks-dresden.mpg.de/~tisean/]
TITAN: A general purpose radiation hydrodynamics code that solves the coupled sets of radiation transfer and fluid dynamics equations on an adaptive mesh in one spatial dimenison (in either Cartesian or spherical coordinates). A technical report and a user's guide are available. I presume this is written in Fortran.
[http://zeus.ncsa.uiuc.edu:8080/lca_intro_titan.html]
Tix: A Tcl/Tk interface extension package containing over 40 mega-widgets including a ComboBox, Motif- and Windows-style FileSelectBoxes, a PanedWindow, a NoteBook, a Hierarchical List, a Directory Tree, a File Manager, and many more. These are higher-level widgets that allow the user to ignore the gory details of Tk widgets and spend more time on the problem being solved. The Tix configuration options are close to the standard Motif look-and-feel and the intrinsics API makes it possible to write new custom widgets using Tcl. The source code is available as well as documentation including a programmer's guide and a reference manual in PostScript and HTML format.
[http://tix.mne.com/]
[ftp://ftp.neosoft.com/languages/tcl/sorted/packages-7.6/devel/]
[http://www.sco.com/skunkware/uw2/interp/Tix8/]
TKAPPS: A package of Tcl/Tk applications including a mail/news reader, a file manager, an editor, and various other applications. The mail/news reader is called VMail3 and is fully described elsewhere. The other programs are:

vvac, a program which turns vacation on and off;

vedit, a basic editor with HTML support and spell checking;

fm, a file manager which uses mailcap files for viewing;

vprog, a single pixel wide program launcher;

vdb, a interface for directory-based databases (e.g. NUAD);

vbiff, a mailbox monitor which supports local files as well as POP3 mailboxes;

vquery, a directory query interface which currently supports NUAD and will support LDAP, whois, finger, and ph; and

vdir, a directory NUAD update interface.

The package is built with Tcl/Tk and is designed for maximum portability across all UNIX platforms. It currently runs on Sun SunOS and Solaris, IBM AIX, HP-UX and Linux Intel platforms and should run on other platforms which support Tcl 7.5 and Tk 4.1 or higher. Some documentation is included in the distribution (especially for VMail3) in HTML format. Note: There was no user jvgulik when I checked the site on 10/14/97.
[http://infoweb.magi.com/~jvgulik]
[ftp://ftp.neosoft.com/languages/tcl/sorted/packages-7.6/apps/tkapps/]
TkDesk: A graphical desktop and file manager for UNIX platforms on which Tcl/Tk is installed. It offers a large set of file operations and services with most parts being highly configurable. The features of TkDesk include:

an arbitrary number of automatically refreshed file browsers and list windows,

configurable file-specific pop-up menus,

drag and drop,

dropping files and directories onto the root window (i.e. desktop),

a configurable application bar with several displays and cascaded pop-up menus for each button,

a history of all operations automatically saved to disk,

file find via several attributes,

a trash can for file and directory deletion,

file operations carried out in the background,

comprehensive online help,

a built-in multi-buffer and undo-capable editor,

coupling with Netscape for displaying HTML files or selected URLs, and

sound support.

TkDesk is available as source code or in binary format for Linux Intel platforms. Its use is documented in online help files and in various hypertext files found at the home site. An introductory article about TkDesk can be found in the March 1998 issue of the Linux Journal.
[http://sd.znet.com/~jchris/tkdesk/]
tkdiff: A Tk front-end to the diff utility.
[http://www.ede.com/free/tkdiff/]
TkDVI: A TeX DVI file previewer based on Tcl/Tk. Features unique to TkDVI include:

a single instance of the program can display multiple DVI windows to show pages from one or more DVI files;

showing adjacent pages in a spread like a book;

showing high level overviews of 16 pages at once;

control by other Tk programs via the send mechanism;

mixing DVI pages with other types of structured graphics; and

encapsulation as a Tk extension package for using the capabilities in other programs.

[http://www.tm.informatik.uni-frankfurt.de/~lingnau/tkdvi/]
TkfPW: A GUI manager for Fortran projects and libraries implemented in Tcl/Tk without any extensions. This package allows the Fortran programmer to configure, building, and run programs and libraries as well as select and list files.
[http://www.ec-nantes.fr/DMN/WWW/Software/TkfPW/]
TkGoodStuff: An X11 utility that is an alarm clock, biff, modem dialer/network status indicator, note taker, web browser launch tool, system load monitor, application/utility menu and whatever else you want. You can easily configure buttons to execute simple tasks, and with Tcl/Tk scripting you can write clients that do fancier things. This package requires Tk4.0 or higher to work.
[http://www.math.columbia.edu/online/tkgoodstuff/]
TkImgMap: A package for the creation of image maps for Web pages. TkImgMap can read GIF and JPEG files, define sensitive areas with a mouse click, move and delete such areas, save a map as a client-side imagemap, and import existing HTML files. This runs on top of Tcl/Tk.
[http://ankif.free.fr/info/TkImgMap_en.html]
tkisem: An instructional emulator for version 8 of the SPARC instruction set. The features include:

full emulation of the SPARC version 8 integer unit;

all exceptions, faults, interrupts and traps are handled by SPARC code that can be examined and modified;

support for a variety of devices including a character console, a graphics accelerator, an interval timer and a UART;

a window to display the registers defined by the integer unit;

windows to display instructions in the program segements for the user and supervisor memories;

breakpoints for user and supervisor instructions; and

an interactive help system.

Source and binary distributions are available, with one of the latter being for Linux Intel platforms. An extensive laboratory/user's manual is available.
[http://www.cs.unm.edu/~maccabe/tkisem/]
TkMan: A graphical hypertext man page and Texinfo browser written in Tcl/Tk.
[http://tkman.sourceforge.net/]
TkNotepad: A notepad editor built using Tcl/Tk.
[http://www.mindspring.com/~joeja/programs.html]
Tkpvm: A package that provides an interface between the Tcl/Tk scripting and interface language and the PVM library for distributed processing.
[http://www.cogsci.kun.nl/tkpvm/welcome.html]
TkRat: See Ratatosk.
Tksh: An implementation of the Tcl C library written on top of ksh93. Tksh emulates the behavior of Tcl using the API provided for extending ksh93, which is similar to the Tcl library in that it allows access to variables, functions and other states of the interpreter. This allows libraries such as Tk to run unchanged on top of ksh93, making it possible to use shell scripts in place of Tcl scripts. This is well-suited for use with Tk since it's backward-compatible with sh, making it easy to learn and extend existing scripts to provide a GUI.
[http://www.CS.Princeton.EDU/~jlk/tksh/]
TkSM: An OpenGL-based 3D modeling extension for Tcl/Tk. This package provides a simple and relatively lightweight tool for displaying polygon-based 3D models from within Tcl/Tk applications. It allows users to define hierarchical models, place groups of models into individual cells, and associate each cell with one or more independent viewports through which the models may be viewed and manipulated. A choice of viewports is available. Viewport widgets are the slower option but give the ability to superimpose text and other canvas elements on top of rendered images and offer faster screen refreshes of static scenes. Canvas viewport items draw directly into OpenGL windows and will therefore render much faster on systems with hardware OpenGL acceleration. TkSM does not provide direct access to OpenGL routines, but it does allow the addition of elementary 3D viewing and modeling capabilities to Tcl/Tk applications.
TkSM offers a choice of several model types including: polyhedra with simple convex polygon faces, line segments, points, spheres, cylinders, and disk. Available model attributes include:

material properties for both front and back faces such as face color, shininess, and emissive, ambient reflectance, diffuse reflectance, and specular reflectance coefficients;

all culling modes;

single-level texture mapping for point, line, and polygonal models;

flat and smooth shading models;

hierarchical models; and

per-face and per-vertex vertex normals.

Viewport attributes include:

up to 8 light sources for each viewport;

light source properties such as ambient, diffuse, and specular color and directional, positional, and spot light;

two-sided lighting; hidden surface removal;

depth-cueing (fog); and

parallel and perspective projection.

VRML files can be imported (only).
TkSM has been tested on several platforms using the Mesa OpenGL-like library and can be readily ported to only platform on which Mesa can be used. It is compatible with Tcl 7.4 and above and Tk 4.0 and above.
[http://www.ibiblio.org/pub/Linux/devel/lang/tcl/]
TkStep: A modified version of Tk with full drag 'n' drop (DND) support and a tkinter module for Python 1.5 which also supports DND. This modifies Tk to look and feel more like the Next interface.
[http://www.ibiblio.org/pub/Linux/devel/lang/tcl/]
TkTeX: A Tk-based interface to TeX and related tools, e.g. editors, previewers, printing programs, and the like. Within the TkTeX GUI a user can select a TeX source file, edit it, compile it with TeX or LaTeX, preview it with xdvi, convert it with dvips, and more.
A source code distribution of TkTeX is available. It is written in Tcl/Tk and requires Tcl 7.4 or later and Tk 4.0 or later, although it works best with versions 7.5 and 4.1 or later. It is documented in a couple of DVI files included in the distribution.
[http://www.cs.indiana.edu/hyplan/ndanner/tktex.html]
tkWorld: A GUI-front end to the UNIX shell written using Tcl/Tk. The features include:

a facility for building, editing and executing scripts without a graphical command history;

the graphical display of command output in a scrollable text viewer;

a graphical installation tool; and

written entirely in Tcl/Tk 8.0 with no additional required libraries.

[http://www.tkworld.org/]
TLCPACK: This package has been renamed regridpack.
TLS: Transport Layer Security is a protocol for providing privacy and data integrity between two communicating applications.
[http://www.ietf.org/ids.by.wg/tls.html]
TMAKE: A tool for creating platform-independent makefiles. It does this by reading a project file, filling in a template, and then producing a makefile. TMAKE was originally developed for producing makefiles for Qt applications, but is sufficiently general to be used for almost any project. A source code distribution is available.
[http://www.troll.no/freebies/tmake.html]
TMath: A Tcl/Tk extension that allows it to control both Matlab and Mathematica processes and to evaluate commands from either package. It provides: two new Tcl commands, i.e. matlab and mathematica; a framework for registering Tcl commands implemented as C++ methods; C++ interfaces for Matlab and Mathematica; and C++ objects to control multiple Matlab and Mathematica processes. TMath does not use pipes to control the processes of these package but rather uses the Matlab Engine interface and the Mathematica MathLink protocol, the former of which is based on memory-to-memory writes and reads and the latter on exchanging data packets.
TMath currently (version 0.1 on 3/97) works with Matlab 4.0, 4.1, and 4.2 and with Mathematica 2.1 and 2.2. It also requires the include files and libraries from either version 7.4 or 7.5 of Tcl. It is known to compile on several platforms, including Linux. TMath is based on an implementation originally created for the Ptolemy environment.
[http://www.ece.utexas.edu/~bevans/projects/tmath.html]
T-Matrix: A set of codes using the T-matrix method for computing electromagnetic scattering. The codes include:

tmq, for randomly oriented nonspherical particles;

amplq, for nonspherical particles in a fixed orientation;

bisphere, for randomly oriented two-sphere clusters with touching or separated components;

scsmf01b, for calculating the entire 2-D scattering matrix and cross-sections for large-scale sphere clusters for fixed orientations of the cluster with respect to a plane, linearly-polarized incident beam;

scsmtm1, for calculating the T-matrix of a sphere cluster and the orientation-averaged scattering matrix and cross-sections; and

spher, a Lorenz-Mie scattering code for polydisperse spherical particles.

[http://www.giss.nasa.gov/~crmim/]
TMN: The Telecommunications Management Network consists of a series of interrelated national and international standards and agreements which provide for the surveillance and control of telecommunications service provider networks on a worldwide scale, i.e. a method to standardize communications equipment among international vendors. TMN also applies to wireless communications, cable television networks, private overlay networks, and many other large-scale, high-bandwidth communications networks. It is primarily a communications concept whose standards define two types of resources: managed systems called Network Elements (NE) and managing systems, e.g. the Operation System (OS). The TMN standards also specify possible interconnection relationships between these resources. In a wider sense the TMN standards also include the specification of the information and means of information transfer across interfaces as well as the processing of that information at both ends of the communications link, although this is not strictly true. See Black (1995a), Glitho and Hayes (1995), and Sidor (1995).
[http://www.itu.int/TMN/]
tmproc: A Python implementation of the international standard ISO/IEC 13250 for Topic Maps. Topic Maps are a standard for layering multidimensional topic spaces on top of information assets, covering such concepts as topics, associations, occurrences and facets/multidata. The features of tmproc include:

importing, exporting, querying and manipulating Topic Maps;

a full set of extensible topic map classes with clearly defined interfaces;

optional architectural processing;

statistical and information printing classes;

a command line utility for interactive exploration; and

introductory and reference documentation.

[http://www.ontopia.net/software/tmproc/]

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

Manbreaker Crag 2001-03-08