Next: Ua-Um Up: Linux Software Encyclopedia Previous: Ta-Tm Contents

Tn-Tz

Last checked or modified: Jan. 8, 2001

TN: A Fortran subroutine for solving unconstrained and simply bounded optimization problems by a Truncated Newton algorithm. TN doesn't assume that the function is convex (so it cannot guarantee a global solution), but does assume that the function is bounded below. It can solve problems having any number of variables, but is most effective when the number of variables is large. See ().
[http://www.netlib.org/opt/]
tn5250: A terminal emulator to IBM 5250 terminals most commonly used in the AS/400 environment. An alpha source code distribution is available.
[http://www.linux-sna.org/software/5250/]
TN-Image: An image analysis program oriented toward scientific and technical image analysis, TN-Image has been used by molecular biologists, forensic pathologists, biochemists, physicists, and others to analyze images. It is also useful for general image viewing and editing and has an easy to use, menu-driven interface based on Motif.
The features of TN-Image include:

viewing images directly or in an editable spreadsheet using integers, RGB values, hex integers, or floating point numbers with changes in the image immediately reflected in the spreadsheet and vice-versa;

transparency, chromakey, and paste functions to create composite images;

scanner interfaces for II/P SCSI scanners with preview scan and interactive image scanning;

creating, cutting/pasting, and adding text labels in multiple fonts and graphic elements such as circles, Bezier curves, and freehand drawing;

handling up to 512 images of any depth simultaneously;

printing to PCL or PostScript printers in CMY, CMYK or RGB formats;

importing and exporting several formats including PCX, IMG, TIF, JPEG, BMP, CIF, TCA, IMG, XDM, FITS, PDS, and ASCII;

creating new custom image file formats;

interconversion of image formats;

solid and gradient flood fill;

color gradient filled wide lines and adjustable size arrow heads;

separate manipulation of R, G and B image planes;

adjustment of color, intensity, contrast, and grayscale mapping;

rotating, resizing, warping, flipping, inverting and remapping colors;

cropping, painting, and spray painting;

rotation of labels and images to any angle;

spray-filtering and spray-math to enable interactive image manipulation on local regions of an image;

convolution filters for sharpening, blurring, edge enhancement, shadow sharpening, background subtract, background contrast, and noise filtering;

interactive creation of arbitrary colormaps or selecting from 10,000 pre-defined colormaps;

a macro language and editor for programming;

an image algebra function that allows multiple images to be subtracted or otherwise transformed according to arbitrary user-defined equations;

RGB and intensity histograms;

viewing multi-frame or 3-D images as a movie;

spot densitometry of rectangular regions or arbitrarily-shaped areas;

strip (scanning) densitometry of transepts, fixed-width rectangular regions, and trapezoidal areas;

2-D Fourier transforms;

convolution of 2 images and image reconstruction using Fourier deconvolution;

distances and angle measurement; and

image algebra which allows user-defined math transformations of images.

Binary versions of TN-Image are available for several platforms including Linux Intel. Versions are available that are both statically and dynamically linked to Motif. A user's guide is available in PostScript format.
[http://las1.ninds.nih.gov/index.nih.html]
[http://www.ibiblio.org/pub/Linux/apps/graphics/misc/]
TNPACK: A package of Fortran 77 programs for minimizing multivariate functions without constraints using a truncated Newton algorithm. TNPACK is especially suited for problems involving a large number of variables. Truncated Newton methods obtain approximate rather than exact solutions, with the truncation accomplished here by using the preconditioned conjugate gradient algorithm (PCG) to approximately solve the equations. The preconditioner is factored in PCG using a sparse modified Cholesky factorization based on the YSMP. This is TOMS algorithm 702 and is documented in Schlick and Fogelson (1992a) and Schlick and Fogelson (1992b).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
TNPP: The Telocator Network Paging Protocol establishes a standard mechanism to move paging and other information between paging terminals regardless of manufacturer. It is a point-to-point communications protocol used to ensure reliable delivery of information from one paging terminal to another directly connected paging terminal.
[http://www.refreq.com/braddye/inter.html]

rtnppd

A daemon that can route TNPP packets between serial links and other rtnppd programs over an IP network. It has blowfish encryption for data security, packet logging, and destination address translation. A source code distribution is available.
[http://members.tripod.com/~Vasim/rtnppd.tgz]
TOAD: A project to develop a modern C++ toolkit for creating graphical user interfaces (GUI) for the X Window System. The TOAD project goals focus on a simple programming interface, minimal network traffic between the X client and server, small header files for faster compilation, support for POSIX threads, platform independence, and good programming and reference manuals.
The project is still under development and a source code distribution of the latest version (0.0.27) is available. Compilation and use require a UNIX/X11 system with gcc 2.7.2 or greater. The documentation is still (7/97) a bit sparse.
[http://www.mark13.de/toad/]
toast: A real-time audio encoder/decoder. See GSM.
Tob: A shell script which is a general driver for making and maintaining backups. Tob can perform full, differential and incremental backups. It also lets you determine the size of the backup before actually making it and maintainlistings of backups made. A source code distribution is available which contains a user's manual.
[http://www.icce.rug.nl/docs/programs/tob.html]
[http://packages.debian.org/unstable/utils/tob.html]
Toba: A Java-to-C translator that translates Java class files into C source code, thus allowing the construction of directly executable programs that avoid the computational overhead of interpretation. It deals with standalone applications, not applets. As of 2/97, Toba runs under SGI IRIX 6.2, Linux 2.0, Sun Solaris 2.5, and Windows NT 4.0, although only the Solaris implementation currently has thread support. It is distributed in source code form. Toba is a product of the Sumatra Project.
[http://www.cs.arizona.edu/sumatra/toba/]
TOCHNOG: A free finite element package with many features. These include:

format free input;

boundary conditions specified at geometrical entities rather than specifying elements and nodes;

output at geometrical points instead of at elements and nodes;

1-, 2-, and 3-D isoparametric elements (i.e. no beams and shells);

linear simplex elements;

1st- to 4th-order bar, quadrilateral and brick elements;

several mesh generation/refinement capabilities including automatic division of macro regions into elements, local h-refinement, global h- and p-refinement, remeshing via equation residues or element shapes, and building an entirely new mesh;

handling fluids via the Stokes and Navier-Stoke equations;

handling solid properties including elasticity, plasticity, damage, thermal stresses, hypoelasticity, viscoelasticity, viscoplasticity, viscosity;

solving ground water flow and wave equations;

nonlocal calculations for softening materials including a gradient model for plasticity;

interaction analysis for automatic fluid-solid interaction;

contact analysis with and without friction;

a choice of description frames including Lagrangian, Eulerian and arbitrary Eulerian-Lagrangian (AEL);

quasi-static and dynamic analyses;

parallelization of a wide range of functionality via multiple threading;

and several other useful features.
A source code distribution of TOCHNOG is available. It is written in C++ and includes makefiles for HP, Linux Intel, SGI, and Sparc platforms. On Linux platforms it can be compiled in either a single- or multiple-threaded version, with the latter using the LinuxThreads package. Documentation is available in the form of a user's guide in PostScript format.
[http://tochnog.sourceforge.net/]
TOD: The Touch Of Death package works with the Sniffit package to enable root to take down any TCP connection on a subnet.
[http://www.pulhas.org/tools/]
tofrodos: A package consisting of programs which convert text files to and from DOS and UNIX formats. The fromdos program converts from DOS to UNIX, replacing CR/LF pairs at the ends of lines with LFs, while the todos program inverts this procedure.
[http://sunsite.unc.edu/pub/Linux/utils/text/]
Togl: A Tk widget for OpenGL rendering. It allows the creation and management of a special Tk/OpenGL widget with Tcl and render into it with a C program, i.e. a Togl program will have Tcl code for managing the interface and a C program for computations and OpenGL rendering. The features include: color-index model support including color allocation functions; support for requesting stencil, accumulation, alpha buffers, etc.; multiple OpenGL drawing widgets; OpenGL extensions testing from Tcl; and simple, portable font support.
The source code for Togl is available. Installation and use of the package requires Tcl 7.4 and Tk 4.0 or later as well as some form of the OpenGL widgets. It can be used with the Mesa OpenGL-like implementation. The software is documented on the site and in the distribution in various files.
[http://togl.sourceforge.net/]
TOLKIEN: The TOoLKIt for gENetics-based applications is a C++ class library whose target users are those involved in GA or classifier system research. The toolkit has a unified framework, is flexible and extendible, and contains a representative collection of data structures and algorithms. This has been tested on and compiles using the GCC/G++ compiler, making it usable on Linux systems. A 110+ page manual in PostScript format contains the documentation for TOLKIEN.
[ftp://alife.santafe.edu/pub/USER-AREA/EC/GA/src/]
TOM: An object-oriented programming language originally developed as an enhanced Objective-C. TOM supports the usability and reusability of objects via classes which are extensible entities; extensions which can add and replace methods, instance variables, and additional superclasses; and extensions which can be added to a program at compile, link, or run time. The TOM compiler, written in Objective-C, compiles TOM source code to C which is then compiled by GCC into an executable.
The features of TOM include:

maintenance of a strict distinction between classes and instances;

multiple inheritance (with repeated inheritance being shared inheritance);

the capability of distributing a class definition over multiple extensions with each extension able to add state or add or replace behavior;

statically bound operations on the built-in types;

dynamically bound method invocations;

fully dynamic run-time including sensible forward, perform, and other methods;

overloading of methods on the types of arguments and return values;

multi-valued returns and multi-threading;

declaring static class variables local to a thread;

optional method parts with default argument values;

maintenance of language semantics in the context of dynamic loading;

public, protected, and private encapsulation of variables and methods;

everthing is an expression with the syntax modeled after C;

allocation of objects from the garbage collected heap;

employment of an exception mechanism;

structured comments;

an easy interface to and from C;

automatic structuring of sources; and

method pre- and post-conditions inherited by overriding methods.

A source distribution of TOM is available as are executables for HP-UX, Linux Intel, NeXT, and Linux PPC platforms. Compilation of the source requires many parts of the GNU software tools suite. Several documents are available in both or either HTML and PostScript format.
[http://www.gerbil.org/tom/]
TOMLAB: This has gone commercial and will eventually be removed from this listing. A general purpose, open and integrated Matlab environment for research and teaching about optimization techniques. TOMLAB is based on and built on top of NLPLIB and OPERA - Matlab toolboxes for, respectively, nonlinear programming and parameter estimation and operational research. The types of optimization problems that can be treated with NLPLIB include:

unconstrained optimization including bound constraints;

quadratic programming;

constrained nonlinear optimization;

nonlinear least squares problems including bound constraints;

exponential fitting problems;

constrained nonlinear least squares problems;

nonlinear time series;

linear programming; and

unconstrained global optimization.

A set of programs and test problems are available for each of these categories.
The types of solvers available in the OPERA portion of the package include those for:

linear programming;

transportation programming;

network programming;

integer programming;

dynamic programming; and

Lagrangian relaxation.

Several algorithms and test problems are available for solving problems in each category.
A source code distribution of TOMLAB is available upon completion of an online form. Documentation includes a 160 page user's guide in PostScript format along with several technical papers in the same format.
[http://www.ima.mdh.se/tom/tom-software/tomlab.htm]
TOMP: A package that allows many analysis and synthesis problems of modern processes to be developed and solved as state and control constrained optimal control problems governed by ODEs with multipoint boundary values. This is TOMS algorithm 733 and is documented in Kraft (1994).
[http://www.acm.org/calgo/contents/]
TOMPI: The Threads-Only MPI package is an implementation of MPI designed to run MPI programs on a single computer, either a single processor or an SMP. TOMPI is designed to be efficient in this enviroment, allowing effective testing, debugging, and tuning of parallel programs on a workstation. It uses threads to minimize communication and context-switching overhead and is specifically tuned for a workstation environment where current implementations like MPICH do not run very well.
A source code distribution of TOMPI is available. It works with several threads packages including Cthreads, so it can be installed and used on Linux Intel systems. Documentation is available in the distribution.
[http://daisy.uwaterloo.ca/~eddemain/TOMPI/index.html]
TOMS: The Transactions On Mathematical Software is a journal published by the ACM in which its Collected Algorithms are published. These are mostly Fortran programs for performing a very wide range of tasks.
The TOMS algorithms and their purposes are:

493: RPOLY, for finding the zeros of a real polynomial;

494: PDEONE, for solving systems of PDEs;

495: CHEB, uses a modification of the Simplex method to obtain a Chebyshev solution to an overdetermined system of linear equations;

496: LZHES, for using the LZ algorithm to solve the generalized eigenvalue problem for complex matrices;

497: DMRODE, for the automatic integration of functional DEs;

498: AIRY, for calculating Air functions using Chebyshev series approximations;

499: EST, an efficient scanning technique for contour plotting;

500: CONMIN, for the minimization of unconstrained multivariate functions;

501: APPROX/EXCH, for performing a discrete Chebyshev curve fit;

502: DERPAR, for finding the dependence of the solution of a nonlinear system on a parameter via a modified method of differentiation;

503: IESIMP, for solving Fredholm integral equations of the second kind;

504: GERK, for global error estimation of ODEs;

505: SPN, a list insertion sort for building a single circularly-linked list;

506: HQR3/EXCHNG, for calculating and ordering the eigenvalues of a real upper Hessenberg matrix;

507: QUINAT, routines for quintic natural spline interpolation;

508: MBPR, routines for matrix bandwidth and profile reduction;

509: PROFIT, a hybrid profile reduction algorithm;

510: STL2, for the piecewise linear approximation of tabulated data;

511: IBESS/JBESS, for computing Bessel functions;

512: PDSQS, a normalized algorithm for the solution of positive definite symmetric quindiagonal systems of linear equations;

513: TRANS, for analysis of in-situ transposition;

514: CFLD, a method of cubic curve fitting using local data;

515: COMB, finds the combination set of N things taken P at a time for a given lexicographical index;

516: RANKCI, for obtaining confidence intervals and point estimates based on ranks in the two-sample location problem;

517: QR2NOZ, for computing the condition numbers of matrix eigenvalues without computing eigenvectors;

518: VMISES, for computing the incomplete Bessel function aka the von Mises distribution;

519: KSP, algorithms for computing Kolmogorov-Smirnov probabilities with arbitrary boundaries;

520: ARSME, an automatic revised simplex method for constrained resource network scheduling;

521: INERFC, for calculating repeated integrals of the coerror function;

522: ESOLVE, congruence techniques for the exact solution of integer systems of linear equations;

523: CONVEX, a convex hull algorithm for planar sets;

524: MP, a multiple-precision arithmetic package;

525: ADAPT, for adaptive smooth curve fitting;

526: IDBVIP/IDSFFT, for bivariate interpolation and smooth surface fitting for irregularly distributed data;

527: GMA, an implementation of the generalized marching algorithm for solving linear systems arising from the five-point discretization of separable or constant coefficient elliptics BVPs on rectangular domains;

528: the PORT utility subset;

529: MC13D, for computing permutations to block triangular form;

530: TRIZD/IMZD/TBAKZD, for computing the eigensystem of skew-symmetric matrices and a class of symmetric ones;

531: GCONTR, a contour plotting package;

532: ROUNDOFF, software for roundoff analysis;

533: NSPIV, for sparse Gaussian elimination with partial pivoting;

534: STINT, an integrator for stiff DEs;

535: QZ, the QZ algorithm for solving the generalized eigenvalue problem for complex matrices;

536: PURDY, an efficient one-way enciphering algorithm;

537: CHARMA, for finding characteristics values of Mathieu's equation;

538: SIMITZ, for computing eigenvectors and eigenvalues of real generalized symmetric matrices by simultaneous iteration;

539: BLAS for Fortran;

540: PDECOL, general collocation software for solving PDEs;

541: ELLPACK, routines for the solution of separable elliptic PDEs;

542: GAM, for solving the incomplete Gamma functions;

543: FFT9, for the fast solution of Helmholtz-type PDEs;

544: L2A/L2B, for finding weighted least squares solutions with the modified Gram-Schmidt algorithm with iterative refinement;

545: OMSFFT, an optimized mass storage FFT;

546: SOLVEBLOK, for solving almost block diagonal linear systems;

547: DCSSMO, for discrete cubic spline interpolation and smoothing;

548: ASSCT, for solving the assignment problem;

549: WEIERSTRASS, for solving the Weierstrass elliptic functions;

550: SPM, for solid polyhedron measure;

551: L1, solves an overdetermined system of linear equations in the L1 norm using a dual simplex method;

552: CL1, for solving the constrained L1 linear approximation problem;

553: M3RK, an explicit time integrator for semidiscrete parabolic equations;

554: BRENTM, for solving nonlinear equations;

555: CY, for using the Chow-Yorke algorithm to find fixed points or zeros of C2 maps;

556: EXPINT, for computing exponential integrals;

557: PAGP, a partitioning problem for linear goal programming problems;

558: LOCATE, for solving the multifacility location problem with rectilinear distance by the minimum-cut approach;

559: HSQP, for finding the stationary point of a quadratic function subject to linear constraints;

560: JNF, for the numerical computation of the Jordan normal form of a complex matrix;

561: HEAP, an implementation of heap programs for efficient table maintenance;

562: FLIST, calculates the shortest path lengths from a specific node to all other nodes in a network as well as the shortest paths between this node and others;

563: CL1, for linearly constrained discrete L1 problems;

564: L1GNR, a test problem generator for discrete lineatr L1 approximation problems;

566: PDETWO/PSETM/GEARB, for solving systems of 2-D nonlinear PDEs;

567: NORMP, for extended-range arithmetic and normalized Legendre polynomials;

569: COLSYS, collocation software for boundary-value ODEs;

570: LOPSI, a simultaneous iteration method for real matrices;

571: TABULS, tabulates statistics for the von Mises and Fisher distributions;

572: HELM3D, for solving the Helmholtz equation for the Direchlet problem on general bounded 3-D regions;

573: NL2SOL, an adaptive nonlinear least-squares algorithm;

574: SPOQS, for computing shape-preserving osculatory quadratic splines;

575: ZFD, for computing permutations of a zero-free diagonal;

576: MODGE, for solving problems of the form AX=B;

577: RC/RF/RD/RJ, for computing incomplete elliptic integrals;

578: BLCFAC/BLCSOL, for solving real linear equations in a paged virtual store;

579: CPSC, for computing complex power series coefficients;

580: QRUP, for updating QR factorizations;

581: HYBSVD, an improved algorithm for computing the singular value decomposition;

582: GPSKC, uses the Gibbs-Poole-Stockmeyer and Gibbs-King algorithms to reorder sparse matrices;

583: LSQR, for solving sparse linear equations and least squares problems;

584: CUBTRI, for automatic cubature over a triangle;

585: EXTRAP, for the general interpolation and extrapolation problems;

586: ITPACK 2C, for solving large, sparse linear systems by adaptive accelerated iterative methods;

587: LSEI, for solving linearly constrained least squares problems with both equality and inequality constraints;

588: HANKEL, for computing fast Hankel transforms using related and lagged convolutions;

589: SICEDR, for improving the accuracy of computed matrix eigenvalues;

590: DSUBSP/EXCHQZ, for computing deflating subspaces with specified spectrum;

591: ANOVA, a matrix-free program for the analysis of variance;

592: RANGE, for computing the optimal estimate of a function;

593: CMMEXP, for solving the Helmholtz equation in nonrectangular planar regions;

594: RELERR, for relative error analysis;

595: HC, for finding Hamiltonian circuits in a directed graph;

596: CONTINPAR, for computing a locally parameterized continuation process;

597: RIBESL, for computing a sequence of modified Bessel functions of the first kind;

598: SQUINT, for computing solvents of matrix equations;

599: GAMPOIS, for sampling from Gamma and Poisson distributions;

600: QUINAT, procedures for quintic natural spline interpolation;

601: SPARSEMAT, a sparse matrix package for special cases;

602: HURRY, an acceleration algorithm for scalar sequences and series;

603: COLROW/ARCECO, for solving certain almost block diagonal linear systems by modified alternate row and column elimination;

604: EXTREM, for calculating an extremal polynomial;

605: PBASIC, a verifier program for American National Standard Minimal BASIC;

606: NITPACK, an interactive tree package;

607: an obsolete system for the management and exchange of programs and other text;

608: HGW, for the approximate solution of the quadratic assignment problem;

609: BSKIN, for computing the Bickley functions;

610: PSIFN, for computing derivatives of the psi function;

611: SUMSL, for unconstrained minimization using a model/trust-region approach;

612: TRIEX, for integration over a triangle using nonlinear extrapolation;

613: MSTPAC, calculates a minimum spanning tree for a connected undirected graph;

614: INTHP, computes the integral of functions which may have singularies at one or both endpoints of an interval;

615: KBEST, finds the best subset of parameters in least absolute value regression;

616: HLQEST, for computing the Hodges-Lehman location estimator;

617: DAFNE, for solving nonlinear differential equations;

618: DSM/FDJS, for estimating sparse Jacobian matrices;

619: DLAINV, automatic numerical inversion of the Laplace transform;

620: references and keywords for Collected Algorithms of the ACM;

621: BDMG, for solving 2-D, nonlinear, parabolic differential equations;

622: MACROPROC, a simple macroprocessor for Fortran 77;

623: INT-SPHERE, interpolation on the surface of a sphere;

624: INT-PLANE, triangulation and interpolation at arbitrarily distributed points in the plane;

625: REGION, relates a 2-D domain to a rectangular grid laid over it;

626: TRICP, a contour plot program for triangular meshes;

627: VE1, for solving Volterra integral equations;

628: GBASIS, for constructing canonical bases of polynomial ideals;

629: GNRT, for solving Laplace's equation in 3-D;

630: BBVSCG, a variable storage algorithm for function minimization;

631: ZERO1/ZERO2, for finding a bracketed zero by Larkin's method of rational interpolation;

632: MKP, for solving the 0-1 multiple knapsack problem;

633: LDA, for the linear dependency analysis of multivariate data;

634: CONSTR/EVAL, for fitting multinomials in a least-squares sense;

635: CAPROX, for the solution of systems of complex linear equations;

636: DSSM/FDHS, for estimating sparse Hessian matrices;

637: GENCOL, for collocation of general domains with bicubic Hermite polynomials;

638: INTCOL/HERMCOL, for collocation on rectangular domains with bicubic Hermite polynomials;

639: OSCINT, for integrating some infinite oscillating tails;

640: SFRMG, for computing frequency response matrices from state space models;

641: NBTERM, for the exact solution of general systems of linear equations;

642: CUBGCV, for calculating minimum cross-validation cubic smoothing splines;

643: FEXACT, for performing Fisher's exact test on unordered contingency tables;

644: BESSFUN, for the calculation of Bessel functions of a complex argument and nonnegative order;

645: GENINV, for testing programs that compute the generalized inverse of a matrix;

646: PDFIND, for finding a positive definite linear combination of two real symmetric matrices;

647: INFAUR, an implementation of quasirandom sequence generators;

648: NSDTST/STDTST, routines for assessing the performance of initial value solvers;

649: FOURCO, for computing trigonometric Fourier coefficients based on Lyness's algorithm;

651: HFFT, a high-order fast-direct solution of the Helmholtz equation;

652: HOMPACK, an implementation of globally convergent homotopy algorithms;

654: GRATIO/GAMINV, for computing the incomplete gamma function ratios and their inverse;

655: IQPACK, for computing the weights of interpolatory quadratures;

656: BLAS, an implementation of level 2 BLAS;

657: CON3D, for plotting contour surfaces of a function of three variables;

658: ODESSA, an ODE solver with explicit simultaneous sensitivity analysis;

659: SOBOL, implements Sobol's quasirandom sequence generator;

660: QSHEP2D, the quadratic Shepard method for trivariate interpolation of 2-D scattered data;

661: QSHEP3D, the quadratic Shepard method for trivariate interpolation of 3-D scattered data;

662: MODUL, for the numerical inversion of the Laplace transform based on Weeks' method;

663: CWI BLAS, a translation of BLAS for the Cyber 205;

664: GBSOL, a Gauss algorithm for solving systems with large, banded matrices using random-access disk storage;

665: Machar, for dynamically determining machine parameters;

666: Chabis, for locating and evaluating roots of systems of nonlinear equations;

667: SIGMA, a stochastic integration global minimization algorithm;

668: H2PEC, for sampling from the hypergeometric distribution;

669: BRKF45, for solving first-order systems of nonstiff initial value problems for ODEs;

670: RKN, for Runge-Kutta-Nystrom integration;

671: FARB-E-2D, find contour lines for values given at rectangular mesh points using nonlinear bicubic Hermite polynomial interpolation;

672: EXTEND, for generation of interpolatory quadrature rules of the highest degree of precision with preassigned nodes for general weight functions;

673: DynamicHuffman, for dynamic Huffman coding;

674: SONEST/CONEST, for estimating the one-norm of a real or complex matrix with applications to condition estimation;

675: SRCF, for computing the square root covariance filter and square root information filter in dense or Hessenberg forms;

676: ODRPACK, for weighted orthogonal distance regression;

677: MASUB, for smooth bivariate interpolation of data points irregularly distributed in a plane;

678: BTPEC, for sampling from the binomial distribution;

679: BLAS, a set of level 3 programs;

680: WOFZ, for evaluating the complex error function;

681: INTBIS, a portable interval Newton/bisection package;

682: TAPAR, implements Talbot's method for Laplace inversion problems;

683: CQCCEX, for computing the exponential integrals of a complex argument;

684: DFC1C2, for interpolation on triangles with quintic and nonic bivariate polynomials;

685: SERRG2, for solving separable elliptic equations on a rectangle;

686: QRDECOMP, for updating the QR decomposition of a matrix;

687: IVODES, a decision tree for selecting suitable codes for solving initial value ODEs;

688: EPDCOL, a more efficient PDECOL code;

689: COLVI2, for using discretized and iterated collocation for solving nonlinear Volterra integral equations of the second kind;

690: PDECHEB, for solving elliptic-parabolic systems of PDEs using Chebyshev polynomials;

691: QUADIMP, improvements for QUADPACK;

692: Sparse BLAS, an implementation and test package for Sparse BLAS;

693: FM, for floating point multiple precision in Fortran;

694: TESTMAT, a collection of test matrices for Matlab;

695: MODCHL, a package for modified Cholesky factorization;

696: GIRI, inverse Rayleigh iteration for complex band matrices;

697: UVIP3P, for univariate interpolation with the accuracy of a third-degree polynomial;

698: DCUHRE, an adaptive multidimensional integration routine for a vector of integrals;

699: TEQUAD, a reimplementation of Patterson's quadrature formulae;

700: SLEIGN, for solving Sturm-Liouville problems;

701: GOLIATH, for the exact analysis of rectangular rank-deficient sparse rational linear systems;

702: TNPACK, a truncated Newton minimization package for larage-scale problems;

703: MEBDF, for solving first-order systems of stiff initial value problems for ODEs;

704: ABDPACK, for solving almost block diagonal linear systems arising in spline collocation at Gaussian points with monomial basis functions;

705: SYL, for solving Sylvester equations;

706: DCUTRI, for adaptive cubature over a collection of triangles;

707: CONHYP, for solving the confluent hypergeometric function;

708: BRATIO, for significant digit computation of the incomplete beta function ratios;

709: MNMTDB/MNMTSG, a set of testing algorithm implementations;

710: EIGENTRI, for computing the eigenvalues and eigenvectors of a general matrix by reduction to general tridiagonal form;

711: BTN, for parallel unconstrained optimization;

712: RANDN, a normal random number generator;

713: VFNLIB, portable vectorized software for Bessel function evaluation;

714: CELEFUNT, a test package for complex elementary functions;

715: SPECFUN, special function routines and test drivers;

716: TSPACK, a tension spline curve fitting package;

717: MLMNP, for maximum likelihood and quasi-likelihood estimation of parameters in nonlinear regression models;

718: SEVAS, for solving the single-input eigenvalue allocation problem;

719: MPFUN, for multiprecision translation and execution of Fortran programs;

720: CUTET, for adaptive cubature over a collection of 3-D simplices;

721: MTIEU, for calculating eigenvalues of Mathieu DEs for noninteger and integer order;

722: IEEE-FP, functions supporting the IEEE standard for binary floating point arithmetic;

723: FRENL, for calculating Fresnel integrals;

724: FINV, for calculating F-percentiles;

725: DMV, calculates the multivariate normal integral;

726: ORTHPOL, for generating orthogonal polynomials and Gauss-type quadrature rules;

727: OBQ, for quantile estimation using overlapping batch statistics;

728: QBPGEN, for generating quadratic bilevel programming test problems;

729: DSYT, for solving general and symmetric Toeplitz systems;

730: UDC, a divide and conquer algorithm for the unitary eigenproblem;

731: MIF, a moving-grid interface for systems of 1-D time-dependent PDEs;

732: POISS, solvers for self-adjoint elliptic problems in irregular 2-D domains;

733: TOMP, modules for optimal control calculations;

734: MINF, for unconstrained nonlinear minimization;

735: DEMODWT, wavelet transform algorithms for finite-duration discrete-time signals;

736: ELLPTI, hyperelliptic integrals and the surface measure of ellipsoids;

737: INTLIB, a portable Fortran 77 interval function library;

738: GFARIT/GFPLYS/GENIN, programs to generate Niederreiter's low-discrepancy sequences;

739: TENSRD, for unconstrained optimization using tensor methods;

740: JPICC/JPICR, for computing improved incomplete Cholesky factorizations;

741: BBQR, least-squares solution of a linear, bordered, block-diagonal system of equations;

742: L2CXFT, for least-squares data fitting with nonegative second divided differences;

743: WAPR, a routine for calculating real values of the W-function;

744: TORUS, a stochastic algorithm for global optimization with constraints;

745: FERMID/FERINC, for computing the complete and incomplete Fermi-Dirac integral;

746: PCOMP, a code for automatic differentiation;

747: MEVAS, for solving the eigenvalue assignment problem for multi-input systems using state feedback;

748: ENCLOFX, for enclosing zeros of continuous functions;

749: FCT, a fast discrete cosine transform;

750: CDT, for the exact solution of large-scale, asymmetric traveling salesman problems;

751: TRIPACK, a constrained 2-D Delaunay triangulation package;

752: SRFPACK, for scattered data fitting with a constrained surface under tension;

753: TENPACK, a LAPACK-based library for the manipulation of tensor products;

754: GQAPD, for the approximate solution of dense quadratic assignment problems;

755: ADOL-C, for the automatic differentiation of algorithms written in C/C++;

756: Schwarz-Christoffel Toolbox, for Schwarz-Christoffel mapping;

757: MISCFUN, for computing several uncommon functions;

758: VLUGR2, a vectorizable adaptive-grid solver for PDEs in 2-D;

759: VLUGR3, a vectorizable adaptive-grid solver for PDEs in 3-D;

760: RGBI3P/RGSF3P, for rectangular grid data surface fitting;

761: SDBI3P/SDSF3P, for scattered-data surface fitting;

762: LLDRLF, for calculating log-likelihood and some derivatives for log-F models;

763: INTERVAL_ARITHMETIC, for performing interval arithmetic;

764: Cubpack++, for automatic 2-D cubature;

765: STENMIN, for large, sparse, unconstrained optimization using tensor methods;

766: vector_pade, for computing Pade-Hermite and simultaneous Pade approximants;

767: COLRED, for the column reduction of polynomial matrices;

768: TENSOLVE, for solving systems of nonlinear equations and nonlinear least-squares problems using tensor methods;

769: GMIS, for the approximate solution of sparse quadratic assignment problems using GRASP;

770: BVSPIS, for computing boundary-valued shape-preserving interpolating splines;

771: rksuite90, for solving initial-value ODEs;

772: STRIPACK, for Delaunay triangulation and Voronoi diagrams on the surface of a sphere;

773: SSRFPACK, for interpolation of scattered data on a sphere with a surface under tension;

774: BCP, for generating box-constrained optimization problems;

775: SLEUTH, for solving 4th-order Sturm-Liouville problems;

776: SRRIT, for calculating the dominant invariant subspace of a nonsymmetric matrix;

777: HOMPACK90, for globally convergent homotopy algorithms;

778: L-BFGS-B, for large-scale bound-constrained optimization;

779: FD, for computing Fermi-Dirac integrals;

780: REXPU, for calculating exponentially distributed random numbers.

[http://www.acm.org/calgo/]
[http://www.acm.org/pubs/contents/journals/toms/]
tomsrtbt: See under distributions.
t1lib: A C library for generating bitmaps from Adobe Type 1 fonts. The bitmaps are generated in a GLYPH-type data format amenable for use with X11 applications. The features of t1lib include:

rasterizing on demand, i.e. rasterization is performed as characters are requested;

full support for the PostScript encoding mechanism;

use of Adobe Font Metric data in the form of AFM files;

automatic generation of metric information in the case of missing AFM files;

a method for directly rasterizing strings of any length in a given font;

optionally rasterizing strings using pairwise kerning information from the AFM file;

availability of ligature information;

support for rotation and arbitrary transformations on the fly;

support for antialiasing;

support for slanting and extending transformations on the fontlevel including bitmap caching;

automatic searching for needed files via information in a configuration file;

both command-line and X11 interfaces; and

support for some decorations like underlining.

A source code distribution is available. This is documented in a user/reference manual available in the obvious formats.
[http://www.neuroinformatik.ruhr-uni-bochum.de/ini/PEOPLE/rmz/t1lib/t1lib.html]
t1utils: A set of UNIX command-line tools for dealing with Type 1 fonts. The programs are:

t1ascii, changes PFB (binary) fonts into PFA (ASCII) format;

t1binary, does the reverse of t1ascii;

t1disasm, translates PFBs or PFAs into a human-readable and editable format;

t1as, does the reverse of t1disasm; and

tlunmac, translates a Type 1 font in Mac format into either PFB or PFA format.

A source code distribution is available.
[http://www.lcdf.org/~eddietwo/type/]
TONS: The Tons Of Numerical Services project aims to create a tool for performing numerical investigations similar to Octave, Scilab, etc. TONS differs from these project in that it uses a three-tiered architecture in which a scheduler receives requests for tasks to be performed from a group of clients and then farms them out to a group of calculation nodes. The scheduler also has the ability to parallelize tasks.
A TONS system will consists of many components including:

a TONS server (or daemon) that receives bytcode execution requests from clients, prepares it for distribution, and then distributes it to various node servers;

node servers that execute codes and pass the results back to the scheduler or server;

a programming language called TAL (TONS Algorithmic Language), a procedural language designed specifically for numerical analysis;

a library of functions called STALL (STandard TAL Library);

a program called TASM (Tons ASseMbler) that creates TBC (Tons ByteCode) for use by the TONS server; and

a client called STC (Simple TONS Clients).

A source code distribution of TONS is available, although it is still (9/99) in the early stages of development.
[http://www.sslug.dk/TONS/]
TOOLDIAG: A collection of methods for statistical pattern recognition with the main application area of classification. Application is limited to multidimensional continuous features without any missing values.
The features of TOOLDIAG include:

several different classifier types including K-nearest neighbor, quadratic Gaussian classifier, radial basis function network with training algorithms, Parzen window with kernel types, the Q* algorithm, etc.;

several search strategies for feature selection including best features, sequential forward and backward search, branch and bound, and exhaustive search;

the combination of the search strategies with several selection criteria including estimated minimal error probability, inter-class distance, and probabilistic distance methods;

feature extraction algorithms including linear discriminant analysis, principal component analysis, and Sammon mapping;

error estimation;

a graphical interface to Gnuplot;

interfaces to other programs including LVQ-PAK and SNNS;

normalization of data samples; and

generation of various statistical data parameters.

The package includes the source code which is written in C. The documentation is contained with a user's manual available in PostScript format.
[http://www.inf.ufes.br/~thomas/home/tooldiag.html]
toolpack: A lint utility for Fortran code. This is an extensive collection of tools for Fortran programmers that includes a pretty printer, a precision converter, a declaration standardizer, static and dynamic program analyzers, a portability checker, and more. The documention is contained within text files in the distribution, and contains strange embedded commands for typesetting. A newer version, i.e. V2.5, is available at the NAG toolpack site.
The tools in in the distribution include:

ISTAL, a documentation generation aid that can be used to create reports on the static and dynamic analysis of a program unit;

ISTAN, a tool for inserting various instrumentation code into a program;

ISTDC/ISTSB/ISTUD, tools for unrolling and condensing DO loops;

ISTCE, a command executor that provides an interface to the Portable File Store (PFS) and other tools;

ISTCI, an experimental intelligent command executor provided as an example of an integrated programming environment created using Toolpack tools;

ISTCN/ISTCR, two tools for changing names within programs;

ISTDC, a data file comparison tool for comparing files of numerica data with embedded text;

ISTDT, converts a token stream to source code with declaration standardization;

ISTED, a Fortran-aware editor;

ISTFD, compares the token streams of two programs and lists the differences;

ISTFR, converts REAL, DOUBLE PRECISION, COMPLEX and DOUBLE COMPLEX constants to a consistent form;

ISTGI, converts the occurrence of specific intrinsic function names into the generic form;

ISTIN, replaces INCLUDE statements with include files;

ISTJF, a symbolic differentiator that converts a modified Fortran function into its derivative;

ISTJS, manipulates FORMAT statements;

ISTLA, subjects source code to full static analysis;

ISTLP, polishes a source code file;

ISTLS, detects and replaces long names with standard-conforming names;

ISTLY, converts source to a parse tree;

ISTME, modifies complicated expressions so the sub-expression stack is kept to a minimum during calculations;

ISTMF, produces a merged output file from the combination of a source code file and a file in token stream form;

ISTMP, a general-purpose macro preprocessor;

ISTPF, a portability verifier that analyzes output from ISTSA to check for correct inter-program-unit communication, unsafe references, and conformance to a subset of the Fortran 77 standard;

ISTPO, the option file editor for ISTPL;

ISTP2, performs source code parameter setting;

ISTQD, a source code declaration standardizer;

ISTQP, source code precision converter;

ISTQT, converts source to a token stream with precision conversion;

ISTRF, a text formatter that formats a text according to embedded commands;

ISTST, a program structurer that rebuilds the flow of control in a program to a standardized form;

ISTSV, for concatenating one or more files into a single storage file;

ISTTD, a differencing tool that checks for differences between any two formatted files;

ISTUN, replaces included files with INCLUDE statements;

ISTVA, produces a human-readable version of the attribute table produced by ISTSA;

ISTVC, a version control program;

ISTVS/ISTVW, produce human-readable versions of the symbol table output by ISTYP;

ISTVT, interactively displays sections of a parse tree as produced by ISTYP;

ISTVW, produces a simple listing of warnings about a program;

ISTX1/ISTX2/ISTX3, experimental expert systems; and

ISTYF, converts a parse tree output by ISTYP into a token stream.

[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
[ftp://ftp.cc.gatech.edu/pub/linux/devel/lang/fortran/]
[http://www.nag.com/public/tpack.html]
TOOPS: A C++ class library for process-oriented simulation primarily of communication protocols. It contains classes for processors, processes, channels, sockets, and messages. The TOOPS code is based on the ANSI language definitions and should be portable to generic UNIX platforms. The source code is available as currently (4/97) runs under HP/UX, SGI IRIX, Linux INtel, DOS and Windows 3.1 platforms. Documentation is included in the distribution in PostScript format.
[ftp://ftp.ldv.e-technik.tu-muenchen.de/dist/INDEX.html]
[http://www.hensa.ac.uk/parallel/languages/c/parallel-c++/classes/toops/index.html]
Top: A program that creates a rolling display of the processes using the most CPU on a UNIX system. A source code distribution is available. It is written in C and can be compiled on most UNIX systems.
[http://www.groupsys.com/topinfo/]
Topic Maps: A standard allowing the creation and maintenance of consistent electronic indices, glossaries, thesauri and tables of contents for multiple heterogeneous documents. These are basically SGML/XML documents in which different element types (as derived from a basic set of architectural forms) are used to represent topics, occurrences of topics, and relationships between (or associations among) topics.
[http://www.infoloom.com/tmsample/pep4.htm]
[http://www.oasis-open.org/cover/gen-apps.html]
TopoVista: A package built on top of OpenGL and GLUT that allows a user to interactively walk or fly around on a surface defined by a USGS Digital Elevation Model (DEM). TopoVista uses a RTIN (Right Triangular Irregular Network) hierarchy to provide an interactive 3-D perspetive view of DEMs. Each view is based on an approximation to the original model, with each approximation sensitive to the current eye position such that closer portions of the terrain are better approximated than those further away. The DEM can be false colored by elevation or colored using a PPM file.
[http://www.cs.arizona.edu/topovista/]
TORA: The Temporally-Ordered Routing Algorithm is a highly adaptive distributed routing algorithm for mobile wireless networks, e.g. a collection of routers equipped with wireless receiver/transmitters that are free to move arbitrarily about. The communication links are functions several variables including router positions, transmission power levels, antenna patterns, cochannel interference levels, etc., with TORA designed to minimize the network performance reaction to such changes.
[http://tonnant.itd.nrl.navy.mil/tora/tora.html]
[http://www.ietf.org/internet-drafts/ draft-ietf-manet-tora-spec-01.txt]
TORUS: A stochastic algorithm for finding the global optimum of a function of n variables subject to general constraints. The algorithm works best with moderate values of n, but can accomodate objective and constraint functions that are discontinuous and can also take advantage of parallel processing. This is TOMS algorithm 744 and is documented in Rabinowitz (1995).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
ToyFDTD: A minimalist, 3-D Finite Difference Time Domain C code for solving problems in electromagnetics. This uses a first-order finite-difference approximation of the differential form of Maxwell's equations to calculate the field intensity values at every point in space for every increment in time over a specified simulation range. See Taflove (1995), Taflove (1998) and Kunz and Luebbers (1993).
[http://www.borg.umn.edu/toyfdtd/]
TPIE: The Transparent Parallel I/O Environment allows the transparent use of parallel disks to solve the problems encountered when attempting to access gigabytes of data when megabytes of RAM are available. It is intended to demonstrate that a parallel I/O system can:

abstract away the details of how I/O is performed so only a simple and high-level interface need be used;

implement efficient I/O-optimal paradigms for large-scale computation;

retain the flexibility needed to allow a wide variety of algorithms to be implemented;

be portable across many platforms; and

be easily extensible.

TPIE is implemented as a set of templated C++ functions and classes. A source code distribution is available which has been successfully installed on Linux platforms.
[http://www.cs.duke.edu/TPIE/]
Tpros: A program for performing Gaussian processes regression. It is available as C source code or in binary form for various UNIX platforms including Linux Intel. Its use and the concepts behind it are explained in several technical reports available at the site. This is freely available only for academic purposes.
[http://wol.ra.phy.cam.ac.uk/mng10/GP/GP.html]
traceroute: A system administration utility to trace the route that IP packets from the current system take in getting to a destination system. This uses raw IP sockets and must be run as root (or installed setuid to root). The package includes the awk programs mean and median to compute the mean and median time to each hop, respectively, from the raw traceroute output.
The source code for traceroute is available and can be installed on most generic UNIX systems via the included autoconfig script. The libpcap package must first be installed for this to work. This is documented in a man page.
[http://www.traceroute.org/]
[ftp://ftp.ee.lbl.gov/]

Xtraceroute

A graphical version of traceroute that visually traces the route traveled by IP packets.
[http://www.dtek.chalmers.se/~d3august/xt/]
Tracker: A program used to play Soundtracker/Protracker MOD files on Linux boxes. The source code is available as is an ELF binary (at the last given URL).
[http://sunsite.unc.edu/pub/Linux/apps/sound/players/]
[http://ftp.cc.gatech.edu/pub/linux/apps/sound/players/]
[http://www.infovav.se/~hubbe/]
traffic-vis: A suite of network monitoring and auditing tools for determining which hosts have been communicating on an IP network, with whom they've been communicating, and the volume of communication taking place on a host-by-host basis. The programs in the package include:

traffic-collector, a daemon that collects and summarizes network traffic;

traffic-resolve, for resolving the hostnames in a traffic-collector log;

traffic-exclude, excludes hosts from the summary based on IP address;

traffic-sort, sorts and limits the size of a report;

traffic-tops, produces a PostScript report;

traffic-totext, produces an ASCII text report; and

traffic-tohtml, produces an HTML report.

A source code distribution is available. Building the package requires libpcap 0.4.
[http://www.mindrot.org/code/traffic-vis.php3]
TRAIAN: A prototype compiler for LOTOS NT, an updated version of the LOTOS formal description language. It is planned to incorporate this into the CADP system.
[http://www.inrialpes.fr/vasy/traian/]
Transcriber: A tool for segmenting, labeling and transcribing speech. This supports most common audio formats as well as remote speech file access via a client/server architecture. Signal and text editors are integrated and synchronized for displaying and playing segments. Multiple languages are supported, and output is in standard SGML format. Binary and source distributions are available. This was developed on a Linux platform using Tcl/Tk with C extensions. Other packages needed are Snack, tcLex and the Sphere libraries.
[http://www.ldc.upenn.edu/mirror/Transcriber/]
TransFig: A set of tools for creating TeX documents with graphics which are portable, i.e. which can be printed in a wide variety of environments. Drivers are available for EPIC and EEPIC macros, the LaTeX picture environment, PIC, PiCTeX, PostScript, and TeXtyl.
Features of TransFig include:

a wide range of supported paper sizes (12);

text rotation; and

a single unified spline model which allows the user to mix interpolated and approximated control points.

The TransFig package can be installed on most generic UNIX/X11 systems, and an Imake configuration file is included with the package to ease the chore of installation. The package is documented in a 23 page user's manual included in the distribution in LaTeX format.
[ftp://ftp.x.org/contrib/applications/drawing_tools/transfig/]
[http://www.ibiblio.org/pub/packages/TeX/graphics/transfig/]
TRANSPORT: A Fortran program used to design charged particle beam transport systems. Many beam line components can be represented including drifts, bending magnets, quadrupoles, sextupoles, octupoles, solenoids, traveling wave accelerating cavities, steering magnets, and plasma lenses. The effect of the beam line on a charged particle trajectory is represented by first-, second- and third-order matrices. Beam phase space dimensions and floor coordinates may also be calculated, with the phase space specified as a matrix of variances and covariances or in accelerator parameters. TRANSPORT will perform parameter fitting, allowing the simultaneous variation of up to 20 selected parameters to satisfy imposed constraints. Misalignments and errors can be simulated and their effects evaluated. Plots can be made of the beam ellipse, any matrix element against accumulated length, and the floor layout of the beam line including 3-D representations of the magnets.
The TRANSPORT program consists of five source code files, i.e. RANPORT, TRANSPORT, TRIN, TRM, and TRSEC, written in Fortran 77. The program is exhaustively documented in a 300 page user's manual available in PostScript format, i.e. Carey et al. (1995).
[ftp://ftp.fnal.gov/pub/transport/]
TransTool: A tool for transcribing spoken language in accordance with a specific transcription standard. This is implemented in Tcl/Tk.
[http://www.ling.gu.se/SLSA/TransTool.html]
TRAP: A generic prototyping system for translators and compilers that is especially suited for special purpose languages of medium complexity. TRAP is written in Python and supports the implementation of compilers and translators only in Python. It integrates concepts from other compiler construction systems, eases the construction of front-ends, and provides substantial support for complex semantic analysis and transformation phases in which abstract syntax tree-like intermediate representation (IR) data structures are manipulated. TRAP processes a compiler description and generates a ready-to-use Python compiler frame module containing the front-end and a hierarchy of IR node classes with prefabricated methods for supporting the subsequent transformations. These transformations are implemented directly in Python, allowing standard Python tools to be used for further development.
The salient features of TRAP include:

an EBNF-style grammar description;

automatic default semantics to ease source-to-source translation;

automatic sequence construction semantics for repetitions and optionals;

type constraints for nonterminals (with semantic values dynamically checked on rule reduction);

automatic front-end generation;

a concise description of node types ordered in a domain hierarchy;

type constraints for node fields that are dynamically checked on node construction;

several constraint types including elementary, nodes, domains and sequences;

automatic generation of a Python class hierarchy for the specified node/domain hierarchy;

synthesis of standard methods for dumping, type checking, pattern matching, traversal, and visiting;

reliable generated IR code in the grammar's semantic actions;

an IR dump method that outputs Python constructor syntax; and

generated code packages into a compiler frame module which can be used in arbitrary Python programs.

A source code distribution is available.
[http://www.first.gmd.de/smile/trap/]
TRAPPER: This has apparently gone over to the dark side and been incorporated into a project called WINPAR for Windows platforms. If you want a version of this for a real OS, then you might try sending an email since they had UNIX versions at one time.
Tree-Ring Toolbox: A collection of Matlab functions for performing various tasks in tree-ring analysis. They include functions for:

I/O and formatting of tree-ring data;

cross-dating and standardizing data;

climate and tree rings;

time series analysks; and

various low level utility functions.

[http://www.ltrr.arizona.edu/~dmeko/toolbox.html]
Triana: This has gone commercial, although the price isn't terribly onerous yet. An environment for developing software modules in which sets of units are connected via mouse actions and combined via the simple click of a mouse to create Java class file executables. The features of Triana include:

a MathCalc module that behaves like a sophisticated mathematical calculator;

binary data Importer and Exporter units;

units for image processing, text processing and various mathematical operations;

a wide range of data types for more flexible importing/exporting of data;

a sophisticated 2-D grapher which can plot any 2-D data set and also features zoom capabilities;

converter units to convert data from one type to another; and

multi-level grouping in which tools can be grouped and viewed in multiple levels.

A source code distribution of Triana is available. It requires JDK 1.1 or higher. All sorts of documentation is scattered about the site.
[http://www.triana.co.uk/]
Triangle: A 2-D quality mesh generator and Delaunay triangular. It generates 2-D Delaunay triangulations, Voronoi diagrams, convex hulls, constrained Delaunay triangulations, and quality conforming Delaunay triangulations. The latter can be generated with no small angles and are thus suitable for use in finite element solutions of various problems. Users can specify constraints on minimum angle and maximum triangle area, and can refine previously generated meshes based on a posteriori error estimates. Support is included for holes, concavities, internal boundaries, and intersecting segments.
The Delaunay and constrained Delaunay triangulations produced are exact although very little speed is sacrificed to gain this sort of robustness. This makes Triangle useful for both finite element problems and computational geometry. It is accompanied by an X Window program called Showme which displays point sets, planar straight line graphs, triangulations, partitions, and Voronoi diagrams as well as creates PostScriput output for all of the above. Both Triangle and Showme are written in portable C (and compiled easily using gcc 2.7.2 on my Linux box). The documentation is contained in online files at the given URL.
[http://www.cs.cmu.edu/~quake/triangle.html]
[http://www.netlib.org/voronoi/]
TRIMAIN: A Fortran program for applying acoustic ray theory to an ocean enviroment in which both the sound speed structure and bottom depth vary horizontally. TRIMAIN can compute transmission loss by direct eigenray addition or by probabilistic distribution of ray arrivals. It can also be used to compute intensity level, travel time, and source and receiver angles for individual eigenrays. A source code distribution is available.
[ftp://oalib.saic.com/pub/oalib/trimain/]
Trimaran: An infrastructure for compiler research in instruction level parallelism (ILP). The system is currently (8/99) oriented towards EPIC (Explicit Parallel Instruction Computing) architectures and supports compiler research in what is typically considered to be back-end techniques such as instruction scheduling, register allocation, and machine-dependent optimizations. This will be useful for investigating explicitly parallel instruction computing (EPIC), high-performance computing systems, instruction-level parallelims (ILP), compiler optimizations and architecture, adaptive and embedded systems, and language design.
The Trimaran infrastructure consists of several components including:

a machine description facility called mdes for describing ILP architectures;

a parameterized ILP architecture called HLP-PD which supports novel features such as predication, control and data speculation, and compiler controlled management of the memory hierarchy;

a compiler front-end called IMPACT for C that performs parsing, type checking and a large suite of high-level, machine-independent optimizations;

a compiler backend (called Elcor) parameterized by machine description that performs instruction scheduling, register allocation, and machine-dependent optimizations;

an extensible intermediate programming representation (IR) that supports modern compiler techniques by representing control flow, data, control dependence, and many other attributes in both internal and textual representations;

a cycle-level simulator of the HPL-PD architecture which is configurable by a machine description and which provides run-time information on execution time, branch frequencies, and resource use; and

an integrated GUI for configuring and running the system.

A source code distribution of Trimaran is freely available for Linux platfaorms running RedHat 5.2 or higher (and mostly likely other standard distributions of similarly recent vintage). A complete installation requires 300 Mb of disk space and several ancillary programs and packages. All are available in the standard distributions except for dot and VCG. Manuals and user guides are available in PostScript format.
[http://www.trimaran.org/]
trimlog: A program for trimming system log files to keep them from growing without bound and exceeding disk capacity. The capabilities including zeroing log files, trimming files by number of lines or bytes, and telling processes to stop writing to the log file while it is being processed.
[http://www.ja.net/CERT/Software/trimlog/]
TrinityOS: This isn't a software package but rather, as the author puts it, a ``step-by-step guide to configuring up a powerful Linux server.'' It is a complete guide to configuring and maintaining a server configuration for both novices and experts, and gives special emphasis to security considerations. It is written in a step-by-step, example-driven style that avoid dwelling on esoteric techical issues that are probably best explored after the box is running. The document features include:

recommendations on picking a distribution;

complete physical and configuration security recommendations and guidelines;

maintaining security on actively maintained systems;

advanced SYSLOG logging;

configuring, compiling, installing and booting a 2.0.3x series kernel;

LILO configuration and security;

full LAN masquerading using a private class B;

advanced packet filter firewall rulesets for MASQ and non-MASQing servers with configurable remote IP address restrictions;

masq port forwarding support;

PPP connectivity to an ISP;

dial-on-demand (Diald) Internet connections;

dual Ethernet network support;

DHCP servers;

NTP time calibration;

a full BIND v8 authoritative domain DNS and DNS caching service;

full sendmail system support with domain masquerading;

the Apache web server;

full ssh telnet support;

using Samba for microshaft Windows file and printing support;

Tripwire security breech monitoring;

software RAID 0 (striping) with two SCSI drives;

PCMCIA PC card services; and

APC SmartUPS powerdown support.

This is quite a valuable resource that requires careful perusal.
[http://www.ecst.csuchico.edu/~dranch/LINUX/index-linux.html]
Trinux: See under distributions.
TRIPACK: A Fortran 77 package that uses an incremental algorithm to construct a constrained Delaunay triangulation of a set of points in the plane. The triangulation covers the convex hull of the nodes but may also include polygonal constraint regions whose triangles are distinguishable from those in the remainder of the triangulation. This allows a nonconvex or multiply connected triangulation to be performed while retaining the efficiency of seaching and updating a convex triangulation. The capabilities include an efficient means of updating the triangulation with nodal additions and deletions. This is TOMS algorithm 751 and is documented in Renka (1996a).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
Tripwire: A program which allows you to determine system integrity by creating a file signature database which can be compared to subsequently created databases. The database contains checksums of important system files which will change if files have been tampered with. Tripwire uses several checksumming algorithms to guard against the possibility of one method being fooled. These methods include MD5, MD4, and MD2 Message Digest Algorithsm, the Xerox secure hash function Snefru, the Secure Hash Algorithm (SHA), and Haval code.
A source code distribution of an early (1994) version, i.e. Tripwire 1.2, is available at the FTP site. The folks who made ensuing versions commercial announced (3/00) that they were making the project Open Source, with the initial release scheduled for the third quarter of 2000. It is documented in a user's manual available in PostScript format as well as in Garfinkel and Spafford (1996). There is an article about Tripwire in the August 1997 Linux Journal.
[http://www.tripwire.org/]
[ftp://coast.cs.purdue.edu/pub/COAST/Tripwire/]
TRLan: A Fortran 90 package for solving real symmetric or complex Hermitian eigenvalue problems. TRLan is designed for very large problems whose discrete forms are too large to store in computer memory, and for which only a small fraction of the total eigenvalues (usually the extreme ones) are desired. This implements the thick-restart Lanczos method and can be used on either a single address space machine or a distributed parallel machine. Most of the arithmetic computuations are performed via calls to BLAS and LAPACK. A source code distribution of TRLan is available which contains a user's manual.
[http://www.nersc.gov/research/SIMON/trlan.html]
troff: A typesetting package whose original version was developed by Joseph Ossanna at Bell Laboratories in 1971. This program, whose ancestor was a program called runoff written at MIT in the 1960s, generated proprietary printer codes for the Wang C/A/T Phototypesetter. Various filters are available to convert these proprietary codes to more useful formats. Brian Kernighan rewrote troff in 1981 to generate a generic typesetting language and called this version ditroff (for device independent troff. He also added some features such as arbitrary line drawing and more flexible font handling. This version is commercially available in a package called Documenter's Workbench (DWB) which contains ditroff along with some other typesettting filters include: pic, for drawing arbitrary line-based graphics; eqn, for constructing mathematical equations; tbl, for specifying and displaying automatically sized and configured tables; grap, which uses pic to construct graphs; and refer, which provides a mechanism for searching for and formatting bibliographic references. The GNU Groff package is a version of ditroff whose functionality includes all of ditroff plus most of the filter capabilities.
Related packages include troffcvt, four version of troff2html, tr2latex, and unroff.
troffcvt: A package that translates troff source code into various other formats including HTML, RTF, or plain text. The package consists of several programs including:

troffcvt, which converts raw troff input into an intermediate form which is easier for the other programs or postprocessors to interpret;

troff2rtf, which converts troff files into RTF format files;

troff2html, which converts troff files into HTML format files;

tc2html, which converts troffcvt output into HTML format;

tr2html-toc, which generates a table of contents from troffcvt output;

unroff, which converts troff documents into plain text; and

tblcvt, which converts troff tables which would normally be processed by the tbl program into a form that can be easily handled by troffcvt.

[http://www.primate.wisc.edu/software/troffcvt/]
troff2html: A Perl program which conversion troff source code into HTML output. It supports both the mm and ms macros. This was last updated in July 1996.
[http://www.pathname.com/~quinlan/troff2html/]
troff2html: Another Perl script for converting troff source code into HTML output. The features of this one include:

understanding -me macros,

understanding strings and sourced files,

running output from preprocessors either through nroff or inlining them as GIF files,

translating all ISO-8859-1 entities,

configurable table of contents, and

configurable navigation bar.

This was last updated in Oct. 1994 since the author has moved on to using LaTeX.
[http://www.cmpharm.ucsf.edu/ troyer/troff2html/]
troff2html: Yet another Troff to HTML converter, with this one designed for Troff with -ms macros. This package approaches the task in stages. First, the raw Troff is translated into HTML, then the -ms macros, then the -mv macros, and finally -man macros. This is written in Perl.
[http://www.dcs.bbk.ac.uk/~mick/html/]
tr2latex: A program to convert Troff source code into LaTeX source code.
[http://www.ibiblio.org/pub/packages/TeX/support/tr2latex/]
TrueReality: A Nintendo 64 emulator for UNIX systems. A source code distribution of this alpha (9/98) package is available.
[http://www.emuhq.com/truereality/]
TrueType: The scalable font technology built into Windoze and Mac systems. This was first introduced on Mac systems on System 6.0 in March 1991, and on Windoze platforms on 3.1 in early 1992. The Windoze version, being only 16 bit, lagged horribly behind the 32 bit Mac version until the release of Windoze 95. Huge gobs of fonts and utilities are of course available for those platforms, although several utilities are now making TrueType fonts available for UNIX/Linux platforms. These include:

Font3D, builds a 3-D model of a word or phrase from any TrueType font;

FreeType, a TrueType font rendering engine library;

gltt, for accessing TrueType fonts from OpenGL;

ttftot42, a program that allows the use of TrueType fonts on PostScript interpreters with a TrueType rasterizer;

xfsft, a set of patches for X11 that enable the use of TrueType fonts; and

X-TrueType Server, allows the X server to use TrueType fonts.

[http://www.truetype.demon.co.uk/]
TRUMPET: The TRiangular Unstructured Mesh generator by Point insErTion is a 2-D triangular grid generator for singly and multiply connected regions. It uses Delaunay triangulation with 5 point insertion algorithms and allows the redistribution of points along boundaries via cubic spline interpolation, and also has viscous grid capabilities near solid walls. It generates several connectivity files including cell to edge, cell to node, edge to cell, edge to node, node to cell, node to edge, and node to node. Graphical output can be obtained in PostScript and FAST formats, with interactive display accomplished via OpenGL and GLUT.
A source code distribution is available by completing a software agreement and returning it. Code distribution is limited to the USA.
[http://www.lerc.nasa.gov/WWW/IFMD/People/jorgenson/trumpet.html]
TSIMMIS: The Stanford-IBM Manager of Multiple Information Sources system is a database-related project to develop tools that facilitate the rapid integration of heterogeneous information sources that may include both structured and semistructured data. It integrates the data and provides users with seamless integrated views of the data. TSIMMIS has components that translate queries and information (i.e. source wrappers), extract data from Web sites, combine information from several sources (i.e. a mediator), and allow browsing of data sources over the Web.
TSIMMIS provides integrated access to heterogeneous sources via a layer of source-specific translators as well as via intelligent modules called mediators. Translators (i.e. wrappers) convert queries over information in the common model into requests that the source can execute, and when the data is returned it is converted back into this model. Mediators are programs that collect information from one or more sources, process and combine it, and export the result to the end user or an application program. Users or applications can interact either directly with the translators or indirectly via one or more mediators.
A source code distribution of TSIMMIS is available. It is written in C and has makefiles for compilation on several platforms including Linux Intel. Documentation is scattered in an array of technical reports available in PostScript format.
[http://www-db.stanford.edu/tsimmis/tsimmis.html]
TSIPP: A 3D image specification and rendering toolkit for use with Tcl/Tk. It is based on SIPP, the Simple Polygon Processor, a library for creating 3D scenes and rendering them using a scan-line z-buffer algorithm. Version 3.1b is compatible with Tcl 7.4 and Tk 4.0 and can render to the new Tk photo image.
[ftp://ftp.neosoft.com/pub/tcl/tclx-distrib/]
TSP: The Time Series and Polarimetry package is a Starlink Project package which handles time series data and polarimetric data, i.e. facilities usually missing from existing data reduction packages oriented towards either spectroscopy or image processing. It can be used from the UNIX shell or from the ICL command language and uses the HDS system for data storage. It is designed to be used in conjuction with other packages such as KAPPA, FIGARO, and CCDPACK. TSP is used to process data from several instruments including:

spectropolarimetry data obtained from the AAO spectropolarimeters using wave-plate or Pockels cell modulators in conjunction with either IPCS or CCD detectors;

infrared spectropolarimetry obtained with the IRPOL polarimeter module in conjunction with the CGS2 grating spectrometer and the UKT6 and UKT9 CVF systems at UKIRT; and

infrared imaging polarimetry obtained with the IRIS instrument at the AAT and with similar instruments.

Time series data can come from a variety of sources and can range from simple single channel photometry to multichannel polarimetric data. A number of formats can be read and processing routines exist for correcting a series for light travel time or atmospheric extinction, merging datasets, binning a series into time bias of a specified size, and calculating a new series which is the time derivative of the intensity data in an old series. Time series data can be plotted either against time or against phase on some period. Time series images, stored by TSP in 3-D datasets, can be read and displayed in various ways. Individual frames can be displayed or a series displayed as a movie, with the cursor able to read positions and data values. Light curves can also be extracted from time series images, and a software tip-tilt correction can be applied to the data. Over 60 functions are available in the TSP subroutine library.
A binary version of TSP is available for Linux Intel platforms. The package is documented in a 76 page user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
TSPACK: A tension spline curve fitting package whose primary purpose is to construct a smooth function which interpolates a discrete set of data points. The function can be required to have one or two continuous derivatives, and if the accuracy of the data does not warrant interpolation, a smoothing function (which doesn't pass through the data points) can be constructed instead. The fitting method is designed to avoid extraneous inflection points and preserve local shape properties of the data, or to satisfy the more general constraints of bounds on function values or first derivatives. The package also provides a parametric representation for constructing general planar and space curves. This is TOMS algorithm 716 and is documented in Renka (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
TSPLIB: A library of traveling salesman and related problem instances. The problem classes available include:

the symmetric traveling salesman problem (TSP);

the Hamiltonian cycle problem (HCP);

the asymmetric traveling salesman problem (ATSP);

the sequential ordering problem (SOP); and

the capacitated vehicle routing problem (CVRP).

[http://softlib.rice.edu/softlib/tsplib/]
TSTOOL: A Matlab and C++ package for nonlinear time series analysis. The functionality of TSTOOL includes:

time-delay reconstruction;

Lyapunov exponents;

fractal dimensions;

mutual information;

surrogate data tests;

nearest neighbor statistics;

return times;

Poincare sections; and

nonlinear prediction.

The package is available under the GPL.
[http://www.physik3.gwdg.de/tstool/]
T/TCP: TCP extensions for Transactions is an experimental TCP extension for efficient transaction-oriented (request/response) service. This extension is backwards-compatible and inhabits the gap between the connection-oriented TCP and the datagram-based UDP. A Linux implementation is available as a patch to the 2.0.32 kernel.
[http://www.kohala.com/~rstevens/ttcp.html]
[http://www.faqs.org/rfcs/rfc1644.html]
ttftot42: A program that allows the use of TrueType fonts on PostScript interpreters with a TrueType rasterizer. A TrueType font can't be converted to a Type 1 font without losing quality, so newer PostScript interpreters (e.g. Ghostscript 5.03 or newer) included TrueType rasterizers. To use a TrueType font with these, it has to be embedded in a PostScript font dictionary in a format called Type 42. This program generates Type 42 fonts from TrueType fonts and can also generate Adobe Font Metrics (AFM) files including kerning information. The features include:

encoding fonts in ISOLatin1 or PDFDoc instead of the default Adobe Standard);

adjusting the font checksum in the head table of the included TrueType font; and

omission of duplicate entries for .notdef in CharStrings dictionary.

A source code distribution is available which requires the FreeType library for compilation and use.
[http://ftp.giga.or.at/pub/nih/ttftot42]
tth: A package that translates TeX source code that uses the plain macro package (i.e. not LaTeX) into a near equivalent in HTML (the LaTeX2HTML package is recommended for LaTeX files and, indeed, was used to create the document you're reading). Inline and display equations are translated into reasonable HTML 3.2 equivalents, although this package does best with documents that are mostly text.
The tth package can be obtained as either flex or C source code or as a binary for Linux Intel platforms. The documentation is mostly contained within a README file. See also Hyperlatex, HyperTeX, LaTeX2HTML, Ltoh, tex2pdf, Tex2RTF, and TeX4ht.
[http://hutchinson.belmont.ma.us/tth/]
TThread: An object-oriented threads library that supports the starting, stopping, and reaping of threads along with mutexes, conditional variables, and messages for synchronization. This is built on top of Pthreads for UNIX platforms and Windows threads on Microshaft platforms. A source code distribution of this C++ package is available.
[http://www.upl.cs.wisc.edu/~stanis/tthread.html]
T-Threads: This has been superseded/replaced by the SMARTS package.
Tulip: An implementation of the HPC++ interface specification for high performance machines. It provides inter-machine communication via one-side (i.e. get and put) operations on typed global pointers and remote method function invocation, and intra-machine lightweight parallel threads with both Java-like and POSIX-like thread APIs. Tulip uses Nexus and its communication layer and can thus support applications across heterogenous architectures. It also incorporates TAU for performance monitoring.
[http://acts.nersc.gov/tulip/]
Turbine: A Java servlet based framework for quickly creating secure web applications, e.g. ecommerce shopping cart systems and bug or project tracking systems. The goal is to create a framework for building re-usable components for creating useful web sites. The features include:

integration with various template systems, e.g. WebMacro, FreeMarker, etc.;

a single entry point servlet model for optimal security and control;

a singleton-based database connection pool (JDBC) with built-in support for most major databases;

parameter parsing for GET/POST/PATH_INFO;

event-based action handling;

implementation of strict MVC guidelines through interfaces, abstract classes and template systems;

integration with object-relational tools;

a component (IDBroker) that abstracts the autoinsert/sequence usage from the database;

a DatabaseMap generation tool that can read a schema and generate Java classes;

a failsafe job-based scheduler system, i.e. a Java-based cron;

GlobalCache, a singleton-based system for caching data across servlets and requests;

DateSelector, a utility for building the HTML for pop-up date menus;

a file upload API;

a generic services API for creating singletons;

Castor service integration;

XML-RPC service integration;

APIs for localization services, JNDI services, and managing users;

temporary and permanent storage/management of user session data;

an Access Control List (ACL) based security system that uses roles and permissions;

integration with JavaMail; and

works with JDK 1.1.X and higher and the Servlet API 2.0 or higher.

[http://java.apache.org/turbine/]
TurboJ: Note: This is apparently only available commercially now (1/01) from the second URL below. It will be removed from the next iteration of the LSE. A Java byte code to native compiler. It does not require the source code but rather compiles byte code coming from the net like the JIT compiler. Unlike the JIT compiler it works in the background and achieves optimizations similar to those seen with traditional compilers, allowing a significant speed-up in running downloaded Java programs. Turbo-J features include: support for a mixed-mode in which compiled and interpreted code can be simultaneously used in an application; support for 100% of the Java core libraries; full compliance with Java semantics; and use of the local platform Java runtime.
[http://www.camb.opengroup.org/openitsol/turboj/]
[http://www.ri.silicomp.fr/adv-dvt/java/turbo/index-b.htm]
TWIG: The Web Information Gateway is an intranet/groupware tool and application framework. It is implemented using PHP and is intended to become a simple, cross-platform, fast and browser-independent way to access or share almost any kind of information. The features currently (7/99) supported by TWIG include:

email via IMAP;

a contact manager;

scheduling;

Usenet newsgroups;

``to do'' lists; and

bookmarks.

Many more features are planned by the developers, with extensions by users also fairly easy due to the modular construction of TWIG. A source code distribution is available under the GPL.
[http://twig.screwdriver.net/]
TWODQ: A Fortran 77 subroutine which computes the 2-D integral of a function over a region consisting of N triangles. The source code for TWODQ is available and it is documented in comment statements in the source code file. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
2K: A component-based network-centric OS for the next millenium. This project seeks to modify resource management is operating systems to accomodate frequent change, i.e. it shifts the emphasis of OS design from more traditional resource management to the management of dynamically changing distributed resources within rapidly changing user environments.
[http://choices.cs.uiuc.edu/2k/]
TWPBVP: A program for the solution of two-point boundary value problems (BVPs). TWPBVP uses a deferred correction method based on mono-implicit Runge-Kutta formulas and adaptive mesh refinement to solve the equations. The problem must be posed as a first-order system and the boundary conditions must be separated for this method to work. The program is documented in a user's manual separately available in LaTeX format. See Cash and Wright (1991).
[http://www.ma.ic.ac.uk/~jcash/BVP_software/readme.html]
TXL: A programming language and rapid prototyping system designed specifically to support transformational programming. The basic TXL paradigm involves transforming input into output using a set of structural transformation rules which describe by example how different parts of the input are to be changed into output. Each TXL program defines its own context-free grammar according to which the input will be structured, and rules are constrained to preserve grammatical structure to guarantee a well-formed result. The TXL processor is a general purpose source-to-source transformation system suited for a wide class of computational problems.
The TXL language/system has been used for:

the rapid prototyping of new language parsers, semantic analyzers, translators, transliterators, and interpreters;

the rapid prototyping of new and domain-directed features and dialects of existing languages;

software code analysis and design recovery;

software restructuring and remodularization;

metaprogramming and retroactive software reuse;

source-level optimization and parallelization;

inter-paradigm program transformation;

logical formulae simplification and interpretation;

program instrumentation and measurement; and

program normalization and structural comparison.

Version 8 of TXL is available in a version called TXL Lite which is free for academic, research and non-commercial use on most UNIX systems. Version 9 is only available as a commercial product. The packages also include documentation in the form of manuals and man pages as well as several example applications. See Cordy et al. (1991).
[http://www.cs.queensu.ca/STLab/TXL/]

TXL-3

An implementation of the TXL language in Modula-3 that supports most of the features in version 7.
[ftp://ftp-i3.informatik.rwth-aachen.de/pub/Modula-3-Contrib/txl-3/]
txObject: A package of C++ libraries for decreasing project development time and increasing software reliability. It provides both embedded and application level projects with a five-layer framework, each offering a unified set of tools allowing developers to focus development efforts. The levels of the framework are:

an object library;

I/O and timers;

threads;

interprocess communication (IPC); and

distributed object communication.

The txObject libraries can be seen as a combination of Java and CORBA for C++. Like the former, txObject offers platform independent built-in and public available support libraries with a common object-oriented feel and data flow model. Like the latter, it provides the capability of creating applications to run in distributed environments on multiple platforms, although as opposed to the latter's loosely coupled client-server model it is a tightly coupled peer-to-peer distributed system.
[http://txobject.sourceforge.net/]
Tycho: An extensible Itcl development environment being developed to use as a GUI for the Ptolemy project. The objectives of the project are to: build a genuinely object-oriented user interface, provide an extensible framework for experimentation with visual syntaxes, extend the non-dogmatic nature of the Ptolemy kernel to the user interface, experiment with design visualization and explore new visual and mixed visual/textual sytaxes for design representation, leverage off work in the Tcl/Tk community to get portable code, and to design a sophisticated, extensible, and interactive documentation system.
The features of Tycho will include:

an integrated HTML-based documentation system (including automatic generation of HTML documentation from Itcl files);

a canvas interface with grouped objects;

an Emacs-like syntax-sensitive text editor;

a Tcl/Tk interactive shell;

a large widget library (e.g. a file browser, spell checker, font selector, preference system, index browser, configurable dialog widgets, an interface to RCS and SCCS, a simple color browser, HTML formatted message widgets, an error handler, a graph display, a tree structure display, a bubble and arc graph editor, an interface to Glimpse, etc.); and

many base classes and widgets for the construction of other applications (e.g. a font manager, menu bar, status bar, tool bar, subpanel, etc.).

The current (3/97) version of Tycho is available in source code format for UNIX, Mac, and Windows NT systems. It requires an installed Itcl with a version number of 2.1 or higher to work. It can also be used with Ptolemy in addition to standalone execution. The documentation is available both online and in PostScript format.
[http://ptolemy.eecs.berkeley.edu/tycho/]
typesetting: This is generally construed to involve embedding commands in a text file that tell a processing program how to typeset the text. An editor is used to embed the commands in a text file after which the source code is either transformed directly into some printable format like PostScript or transformed into an intermediate format which is then transformed into a printable format using a separate filter program. An example of the latter is TeX which produces an intermediate format called DVI which is transformed into PostScript with a program called dvips. The former is exemplified by Lout which transforms the source directly into PostScript. Contrast this with word processing and text markup packages.
Available typesetting systems include:

Groff

Lout

Quikscript

TeX
TyVIS: A VHDL simulation kernel built on top of the WARPED Time Warp simulation kernel. This provides parallel VHDL simulation capabilities for VHDL that has been translated into the TyVIS C++ intermediate form. A source code distribution is available which requires GCC 2.7.2 or higher for compilation in addition to the WARPED package.
[http://www.ececs.uc.edu/~paw/tyvis/]

[ home / linux ]

Next: Ua-Um Up: Linux Software Encyclopedia Previous: Ta-Tm Contents

Manbreaker Crag 2001-03-08