next up previous contents
Next: Cn-Cz Up: Linux Software Encyclopedia Previous: Bn-Bz

Ca-Cm

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z  

Last checked or modified: Aug. 21, 1997

[home / linux ]

 
C
C is second only to Fortran in the amount of code for numerical and scientific applications that's available. On Linux boxes the C language and the GNU C compiler (GCC) are inextricably linked, making the Linux GCC FAQ a valuable resource. Also handy is the comp.lang.c FAQ Quite a bit of interesting history can be found at the Programming in C pages. The SNIPPETS Collection is an archive of over 675 separate files containing over 90,000 lines of mostly C and C++ source code containing answers to the most common coding problems. Some popular and useful textbooks which either cover the basic language or its use for performing numerical tasks are Harbison and Steele (1995), Kernighan and Ritchie (1988), Kochan and Wood (1991), Libes (1993), Oualline (1993), Plauger (1992), Plauger and Brodie (1996), Press et al. (1994), Rojiani (1996), Sedgewick (1990), and Shammas (1995).  
C++
There are an increasing number of resources about scientific and numerical programming using C++ available on the web. Most Linux users use the GNU C++ compiler (G++), information about which can be found in the G++ FAQ . Many general C++ resources can be found at Quadralay's C++ Archive . A nice introduction to the numerical aspects of C++ is the C++ Programming for Scientists tutorial by R. Pozo and K. Remington, and collections of links to software and related items can be found at the object oriented numerics pages of Phil Austin and the University of Waterloo There is also an Available C++ libraries FAQ . There is a site devoted to the STL (Standard Template Library), which is a library of container classes and generic algorithms that will eventually be part of the C++ standard. Some numerically oriented C++ libraries described hereabouts include LAPACK++, IMO++, MV++ and SparseLib++. The Blitz++ and Template Numerical Toolkit projects are both concerned with creating better C++ libraries for numerical work, with the latter being the planned replacement for the four previously mentioned libraries. See also the texts Barton and Nackman (1994), Shammas (1995), and Buzzi-Ferraris (1993) as well as the series of papers Haney (1994), Robison (1996), Haney (1996), and Furnish (1997) detailing the progressive modifications of C++ to make it a better tool for scientific computation. Textbooks which cover the basic language and seem interesting or important are Ellis and Stroustrup (1990), Koenig (1996), Lippman (1989). Lippman (1997), Oualline (1995), Plauger (1995), Satir and Brown (1995), Stroustrup (1991), Stroustrup (1994), and Sedgewick (1992). The C++ libraries contained within this compilation include:

 

c++advio
A C++ class library containing code that performs: a variable-bit coding of sequences of integers (including arithmetic compression), a trick of sharing a stream buffer among several streams, handling of extended file names, and explicit endian specification in dealing with integer streams. It also includes a Vocabulary package containing (poly/homo)morphic dictionaries with a dynamic inheritance path as well as a few convenience functions and classes. A source code distribution is available which has been compiled using gcc 2.7.2. Documentation includes a README file and comments within the code itself. [http://www.lh.com/oleg/ftp/packages.html]

 

C++SIM
An object-oriented simulation package written in C++. It provides discrete event process-based simulation similar to SIMULA's simulation class and libraries. The capabilities include SIMULA-like simulation routines, random number generators, queueing algorithsm, and thread package interfaces, entity and set manipulation facilities similar to SIMSET, classes that allow non-causal events to be handled, various statistical gather routines, and debugging classes. This package will work on Sun, HP and Linux platforms with the supported thread package for the latter being the GNU Rex lightweight processes library. Documentation includes manual pages and a user's guide See Little and McCue (1993). [http://cxxsim.ncl.ac.uk/]

 

CACAO
A 64-bit just-in-time (JIT) compiler for Java which translates Java byte code on demand into native code for the Alpha processor. The stack-oriented Java byte code is transformed into register-oriented intermediate code with local variables and stack locations replaced by pseudo registers to eliminate the 32-bit restriction on address types. A fast register allocation algorithm is then used to map the pseudo registers to machine registers. CACAO is up to 85 times faster than the JDK interpreter and 7 times faster than the Kaffe compiler, although it is slightly slower than equivalent programs written in C. Binary versions of CACAO are available for Linux Alpha and Digital UNIX platforms. It can be used with the class library of JDK 1.0.2, although it does not support AWT. Work is underway to integrate this with the BISS-AWT library. This is currently documented in a man page and in various pages online at the site.

[http://www.complang.tuwien.ac.at/java/cacao/]

 

CACTVS
A distributed client/server system for the computation, management, analysis, and visualization of chemical information of any type, even that which is defined dynamically or ad hoc. CACTVS uses a worldwide network of databases with property descriptions, computational modules, data analysis tools, visualization servers, data type handlers, and I/O modules to achieve unlimited extensibility of its capacities. The flow of computation is specified by connecting icons representing modules onto workbenches, i.e. a visual programming paradigm. Modules can be obtained from the network of databases, and computations can proceed locally or on remote sites in either real-time or batch-mode. Access can be controlled to keep individual nodes from being overwhelmed with any tasks or set of tasks. The system, when queried, consults the network of databases to attempt to retrieve any available information about the steps necessary to obtain knowledge about a given structure. CACTVS is a set of tools in the form of scripts developed using the Tcl/Tk language (except for the server which is a precompiled binary for various architectures). The tools include: and much more.

The binary server distribution is available for several platforms including SGI IRIX, Sun SunOS, and Linux Intel. The rest of the tools are all written in standard Tcl/Tk for which a distribution is included in each package. There is currently (6/97) a manual for the structure editor but not much documentation for the other programs.

[http://schiele.organik.uni-erlangen.de/cactvs/index.html]

 

Calc
This GNU package is an advanced calculator and mathematical tool that runs as part of the Emacs environment. Some of its features are arbitrary precision integers and floating-point numbers, algebraic manipulation features including symbolic calculus, graphics using Gnuplot, and extensive library of mathematical functions, etc. It comes with a 500+ page manual and is written in Elisp, the Lisp dialect in which Emacs is written, and as such must be compiled using Emacs. This further implies that you must have Emacs installed before you can use this. The source code file has a name of the form calc*.tar.gz. [http://www.gnu.ai.mit.edu/order/ftp.html]

 

CALC
A calculator program for doing arbitrary precision integer arithmetic. This includes almost 60 built-in functions of interest to number theorists. It is written in ANSI C and portable to most platforms with an appropriate compiler. It is documented in an ASCII text file. [http://www.maths.uq.edu.au/~krm/krm_calc.html]

 

Calypso
A prototype software system for writing and executing parallel programs on non-dedicated platforms using off-the-shelf networked workstations, operating systems, and compilers. Calypso features a simple programming paradigm which incorporates shared memory constructs, the separation of the program and the execution parallelism to allow programs to scale as computers join an ongoing computation, transparent use of unreliable shared resources via provision of dynamic load balancing and fault tolerance, and effective performance for large classes of coarse-grained computations. Calypso programs are written in Calypso Source Language (CSL) which is essentially C++ with an added construct to express parallelism. CSL is based on a shared memory model and easy to learn and use. A unified set of mechanisms called eager scheduling and collating differential memory is used to provide the functionality of Calypso. Eager scheduling is a mechanism for assigning concurrently executable tasks to the available machines where any machine can execute any enabled tasks independent of whether the task is already being executed on another machine. This leads to free machines doing more work than loaded ones and a balanced system. Collating differential memory provides logical coherence and synchronization while avoiding false sharing. Memory updates are collated to assure exactly-once logical execution and they are transmitted as bitwise difference to prevent false sharing.

A Calypso distribution for Windows NT platforms has been released and a UNIX-based distribution for Sun SunOS and Solaris and Linux Intel platforms has been implemented but not yet (6/97) released. The details of the system are documented in some technical reports available in PostScript format.

[http://www.cs.nyu.edu/milan/]

 

CAMAC
The Computer Automated Measurement And Control system is a modular instrumentation and digital interface system defined as standardized instrumentation system. It features a fully specified data highway together with modular functional units that are completely compatible and that are available from diverse sources. The CAMAC system is used at almost every nuclear physics research laboratory and many industrial sites, primarily for data acquisition but also for remotely programmable trigger and logic applications. Its function is to provide a scheme allowing a wide range of modular instruments to be interfaced to a standardized backplane called a DATAWAY, which is interfaced with a computer. The DATAWAY provides module power and address, control and data buses, and the lines include digital data transfer, strobe signal, addressing, and control lines. CAMAC-related software for Linux systems includes:

[http://www.ifh.de/~ole/camac/]
[http://www-ols.fnal.gov/ols/www/camac/GSinCAMAC.html ]

 

CAMAC-Linux
A package of CAMAC device drivers. The CAMAC controllers supported are: A source code distribution is available which includes a user's manual. [http://www.ifh.de/ ole/camac/]

 

Cambridge Modula-3
A modified version of the DEC SRC Modula-3 system which includes an updated build system with configuration file support, language additions to allow debugging, support for gcc on Windows 95 and NT, and some primitive support for recovering from running out of virtual memory. Distributions of Cambridge Modula-3 are available in source code form, as bootstrap binaries, or as minimal binaries. The bootstrap binaries contain the bare essentials needed to start compiling the rest of the system, while the minimal binaries also contain various additional packages. Binary packages are available for Linux Intel and Windows 95/NT platforms.

[http://www.cl.cam.ac.uk/m3doc/linux/cambridge.html]

 

Camera
A FITS image display and analysis tool for UNIX platforms which features histogram adjustment, magnifying lens, image blink, a FITS header editor/reader, and a Hubble Guide Star catalog overlay. It can also solve for World Coordinate System values using a pattern matching algorithm and write the resulting key words into the FITS header. There is a photometry tool which supports both differential and absolute photometry, including corrections for extinction and color. The source code for Camera is available. It is written in C and can be compiled on generic UNIX/X11 platforms using the Motif library. Binary distributions are also available for Linux Intel, Sun Solaris, and Unixware platforms.

[http://www-astro.physics.uiowa.edu/]

  

Caml Special Light
This has been superseded by Objective Caml.

 

CAN
The Controller Area Network is a serial bus system protocol suited for networking intelligent devices as well as sensors and actuators within a system. CAN is a system with multi-master capabilities, i.e. all nodes are able to transmit data and several nodes can simultaneously request the bus. Subscribers or stations are not addressed, but rather prioritized messages are transmitted wherein a transmitter sends a message to all CAN nodes, and each node decides on the basis of the received identifier whether it should process the message. It is a simple protocol that can be implemented at low cost. A Linux driver for the CAN protocol can be found in the can4linux package. [http://www.can-cia.de/]

 

can4linux
A Linux driver intended to provide a common API for a full-featured and sophisticated CAN development environment, where CAN is a two wire serial broadcast transmission protocol used in industrial control, hydraulic and automotive applications. The features of can4linux include: A source code distribution of CAN is available. Installation and use requires both LDDK and Tcl/Tk.

[ftp://ftp.llp.fu-berlin.de/LINUX-LAB/CAN/]
[http://www.llp.fu-berlin.de/pool/newproj/CAN/ ]

 

Candleweb
A software architecture for efficiently implementing educational and commercial presentations using real-time interactivity and fast graphics in animations, fully integrated with the Web. CandleWeb is the name of the architecture and the client browser (available as source code and in binary form for several platforms including Linux). Other components of the system are Awe, the language used for programming applications, and Awe Composer, a tool for efficient animation implementation. [http://www.candleweb.no/]
[http://www.vaxxine.com/candleweb]

 

CAP
The Columbia Appletalk Package implements the AppleTalk protocol stack on UNIX machines. The primary applications provide an AppleShare 2.1 compatible server (aufs), a LaserWriter Spooler (lwsrv), and a program to printer to LaserWriters (papif). Various other contributed utilities and programs are included with the package. The source distribution for CAP is available and can be installed on most UNIX platforms. On some UNIX boxes external hardware is needed to translate Appletalk into IP, but support for this is provided in the kernel for Linux and some other systems. The CAP system is documented in man pages and in various ASCII README files. See also netatalk, hfs_fs, hfsutils, MacGate, and Linux Services for Mac and Windows Users . [http://www.cs.mu.OZ.AU/appletalk/cap.html]

 

CAP
The Culvert Analysis Program is a program that follows standard USGS procedures for computing flow through culverts. It can be used to develop stage-discharge relationships for culverts and to determine discharge through culverts from high water marks. It can compute flows for rectangular, circular, pipe arch, and other nonstandard-shaped culverts. CAP solves the 1-D steady-state energy and continuity equations for upstream water surface elevation given a discharge and a downstream water surface elevation. A source code distribution of CAP for UNIX platforms is available. The primary documentation is contained within Fulford (1995). This is part of the USGS Water Resources Applications Software collection.

[http://water.usgs.gov/software/Cap.html]
[http://www.geogr.uni-jena.de/software/Cap.html ]

 

Card Services
A complete PCMCIA support package for Linux platforms. It includes a set of loadable kernel modules (LKM) which implement a version of the PCMCIA 2.1 Card Services applications interface, a set of client drivers for specific cards, and a card manager daemon which can respond to card insertion and removal events by loading and unloading drivers on demand. It supports the hot swapping of PCMCIA cards so they can be inserted and ejected at any time. The current (6/97) package supports many ethernet cards, modems and serial cards, several SCSI adapers, and some SRAM and FLASH memory cards. All common PCMCIA controllers are also supported so it can run on most Linux-capable laptops. A list of supported devices is too long to reproduce here and can be found at the site. The Card Services package is available in source code format. It is written in ANSI C and can be compiled and installed on Linux platforms. It and PCMCIA in general are documented in the Linux PCMCIA HOWTO and the PCMCIA Programmer's Guide, both of which are available in both HTML and PostScript format.

[http://hyper.stanford.edu/HyperNews/get/pcmcia/home.html]

 

Casbah
A project to build an integrated content management system for Linux that provides for web development, content creation, and content management. It is planned to be an extensible, multi-user, multi-platform environment for total content management. This project started in 1/98 and is still in its infancy. [http://www.ntlug.org/casbah/]

 

CASE
The Cellular Automaton Simulation Environment is a toolkit for visualizing discrete models in 2-D, i.e. cellular automata. The goal of this project is to create an integrated framework for creating generalized cellular automata using the object oriented features of C++. The CASE tool consists of a classical finite state machine and a visualization system or presentation manager. A finite state machine is an abstract system which can exist in any of a discrete set of states or conditions, with the state at any instant characterized by the collective state of all of the individual cells which comprise the machine. The system evolves in time according to well-defined rules iteratively applied to each cell. An example is the Game of Life popularized by John Conway. The presentation manager can display the state of the simulation in a variety of user-configurable ways. The principle class objects comprising CASE are: CAApp, a main class used to control the application; CAModel, a class responsible for updating the simulation according to a given set of rules; CAVisual, a class responsible for all drawing and text output in the main window; CACell, a class containing the elementary simulation particles which each one having a set of properties which can change in various ways during the simulation; CAEnviron, an object which defines the pattern of cells in a simulation; CAGrid, a superclass of all environs with fixed geometry; and CAProperty, a class of properties for defining the states of cells. There is also an X2Dview widget class for drawing and animation in 2-D coordinate systems which is compatible with X11R5.

A source code distribution of CASE is available. It is written in C++ and can be compiled with recent versions of g++. It is documented in a user's manual available in PostScript format.

[http://www.iu.hioslo.no/~cell/]

 

CASMSIM
A microassembler and simulator package for the Classic series of Hewlett-Packard (HP) handheld calculators. The Classic series includes the HP-35 Scientific, HP-80 Financial, HP-45 Advanced Scientific, HP-65 Card Programmable Scientific, HP-70 Business and HP-55 Programmable Scientific models. It is written in C and runs under UNIX with X11. A source code distribution is available under the GPL. [http://www.brouhaha.com/~eric/hpcalc/csim/]

 

CCDPACK
The Charge-Coupled Device PACKage is a package of programs for reducing CCD-like data which allow you to debias, remove dark current, flatfield, register, resample, and normalize your data. CCDPACK is designed to ease the process of data reduction by allowing the basic steps to be set up using an X-based GUI (XREDUCE) which controls an automated reduction system. No prior knowledge of the package or of CCD is needed to start using this package. The core of the package is a suite of programs designed to assist in the processing of large amounts of data (and which are used by the GUI application). These programs perform the usual instrumental corrections as well as defect removal and generating and propagating data errors. The program core of CCDPACK includes:

A binary version of CCDPACK is available for DEC Alpha, Linux Intel, and Sun Solaris platforms. It is documented in a 170 page user's manual available in TeX DVI or PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

CCF
Collaborative Computing Frameworks is a suite of software systems, communications protocols, and other tools that enable collaborative, computer-based cooperative work. The package constructs a virtual work environment called a Collaboratory on multiple computers systems connected via the Internet. The goal of the project is to evolve a virtual environment for distributed computation that supports integrated human audiovisual communication, high performance heterogeneous computing, and distributed data management facilities. The programs comprising CCF include:

A source code distribution of CCF is available as are binary distributions for several platforms including Linux Intel. Documentation is contained within several ASCII README files scattered through the distributions.

[http://emily.mathcs.emory.edu/ccf/]

 

ccmalloc
A memory profiling and malloc debugging library for C and C++ programs which can locate leaks, multiple deallocations, and memory corruptions. It also detects under writes and over writes, detects writes to already deallocated data, compiles allocation and deallocation statistics, applies to optimized and stripped code, provides file and line number info for the whole call chain, requires only linking with the library and no recompilation, efficiently represents call chains, sorts, has customizable resource usage, and pretty prints call chains. A source code distribution of ccmalloc is available. It is written in C and can be compiled on most available C compilers. [http://iseran.ira.uka.de/~armin/ccmalloc/]

 

cd
CGM Draw is a graphics library that allows the quick drawing of images complete with lines, arcs, rectangles, polygons, text and multiple colors. Geometric patterns can also be filled or have a hatch pattern. The output is a standard CGM file. This is partially based on the gd package. Cd will compile using a standard ANSI-C compiler such as gcc. The documentation is available online in hypertext format. [http://speckle.ncsl.nist.gov/~lsr/cgm.htm]

 

cdb
A fast, reliable and lightweight package for creating and reading constant databases. It was designed to be used in mission-critical applications like email, with database replacement being safe against system crashes. The features of the cdb database structure include fast lookups, low overhead, no random limits, fast atomic database replacement, and fast database dumps. A source code distribution of cdb is available. [ftp://koobera.math.uic.edu/www/cdb.html]

 

CDE
The Common Desktop Environment is a real pig of a GUI for UNIX/X11 systems. There is an introductory article about the CDE in the March 1998 issue of the Linux Journal.

 

CDF
The Common Data Format is a self-describing data abstraction for the storage and manipulation of multidimensional data in a discipline-independent format. The CDF distribution contains a library of functions for creating CDF applications as well as a toolkit of programs for performing various CDF manipulations. The toolkit includes:

A source code distribution of CDF is available for generic UNIX platforms. It is documented in a user's guide and separate reference manuals for the Fortran and C interfaces.

[http://nssdc.gsfc.nasa.gov/cdf/cdf_home.html]

 
makeCDF
A toolf or reading in flat data sets in both binary and text form and generating CDF datasets from them. MakeCDF is written in standard ANSI C and still (12/97) under development. [http://nssdc.gsfc.nasa.gov/space/spdf/makecdf.html]

 

CDFLIB
A library of Fortran routines for computing the cumulative distribution functions, inverses and parameters of the distribution for beta, binomial, chi-square, noncentral chi-square, F, noncentral F, gamma, negative binomial, normal, Poisson, and Student's t distributions. Given values of all but one parameter of a distribution, the other is computed. The source code is available and the documentation is contained within the code itself as well as in ASCII files within the distribution. [http://www.stat.cmu.edu/general/]

 

cdk
The Curses Development Kit is a package of widgets for creating Ncurses-based full-screen user interfaces. Each widget can display color or other character attributes, with cdk including an attribute/color format command set which allows the simple adding of colors and attributes. The available widgets: are Alphalist, which allows a user to select from a list of words; Calendar, a simple calendar widget; Dialog, which prompts the user with a message to which a response can be made from provided buttons; Entry, which allows information entry; File Selector, a file selector written from lower-level widgets; Graph, which draws a graph; Histogram, which draws a histogram; Item List, which creates a pop-up field allowing a user to select one of several choices; Label, which displays messages in a pop-up box; Marquee, which displays a message in a scrolling marquee; Matrix, which creates a complex matrix iwth lots of options; Menu, which creates a pull-down menu interface; Multiple Line Entry, which creates a multiple line entry field; Radio List, which creates a radio button list; Scale, which creates a numeric scale; Scrolling List, which creates a scrolling list/menu list; Scrolling Window, which creates a scrolling log file viewer; Selection List, which creates a multiple option selection list; Template, which creates an entry field with character sensitive positions; and Viewer, which is a file/information viewer useful for displaying lots of information.

The distribution contains the source code which is written in C. The library has been compiled on Sun SunOS and Solaris, IBM AIX, HP-UX and Linux Intel platforms. Each of the widgets is extensively documented in a separate man page.

[http://sunsite.unc.edu/pub/Linux/libs/]

 

CDRIV/DDRIV/SDRIV
A package of Fortran routines for solving ordinary differential equations (ODEs) with initial conditions, i.e. IVPs. The different versions are for, respectively, single precision, double precision, and complex precision ODEs. There are also three versions of each of these which have increasing degrees of flexibility and complexity. CDRIV1 is the simplest and should be used for routine problems with no more than 200 ODEs. It uses a numerical approximation of the Jacobian matrix of the right hand side and the stiff solver option. CDRIV2 is used for problems for which CDRIV1 is inadequate. It contains a nonstiff equation solver and a root finding option in addition to the capabilities of CDRIV1. CDRIV3 is the most flexible and complex of the programs. Its additional features include the ability to exploit band structure in the Jacobian matrix, the ability to solve some implicit DEs, the option of integrating in the one step mode, the option of allowing the user to provide a routine to compute an analytic Jacobian matrix, and the option of allowing the user to provide a routine to perform the matrix algebra associated with corrections to the solution components. The CDRIV/DDRIV/SDRIV program suite is available as Fortran 77 source code. The use of each is documented in comment statements within the source code files. This is part of CMLIB.

[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]

 

cdt
A portable container data types library that provides a uniform interface to manage objects in dictionaries based on various storage methods, e.g. list, stack, queue, ordered set/multiset, and unordered set/multiset. Each dictionary consists of a discipline to describe objects and attributes and a storage method to specify storage mechanisms. The disciplines can be used to create dictionaries that are either set-like (i.e. addressed by object comparisons) or map-like (i.e. addressed by keys) as well as to share objects across dictionaries that may even reside in different processes. Storage methods define how objects are stored and accessed. Currently (12/97) available methods include: dtset, which stores unique and unordered objects in a dynamically grown hash table with move-to-front chains; dtbag, which stores repeatable and unordered objects in a dynamically grown hash table with repeated objects kept together; dtoset, which stores unique and ordered objects in a splay tree; dtobag, which stores repeatable and ordered objects in a splay tree; dtlist, which stores repeatable and unordered objects in a list with objects always inserted in ront of some current position pointer; dtstack, which stores repeatable and unordered objects in a stack in reverse order of insertion; and dtqueue, which stores repeatable and unordered objects in a queue in order of insertion. A source code distribution of cdt is available. It is written in C and can be used from both C and C++ programs. It is documented in a technical report available in PostScript format.

[http://www.research.att.com/sw/tools/cdt/]

 

cdv
A cartographic visualization program in which geographic entities are represented by geometric symbols, with each symbol represented as an object with defined visual characteristics such a color, size and texture. With cdv dynamic maps can be created, e.g. a slider bar can be used to specify time and moved to advanced the map through time. Items can also be tagged with data values which can be used to visually display information or to retrieve the figures via interrogation with the mouse. Two versions of the software are available. The first is for enumerated data which can be expressed in chloropleth maps, scatter plots, and similar views. The second is for time-space data, allowing temporally varying spatial views to be explored as time series animations. Source code distributions of both versions of cdv are available. Both require the use of Tcl/Tk versions 7.6 and 4.2 or newer, respectively. Documentation is scattered about the site and the distribution.

[http://midas.ac.uk/argus/Software/CartoViz/index.html]

 

cdwrite
A program used to record data or audio compact discs (CDs) on an Orange Book CD-ROM recorder. This will only write single session, Red/Yellow Book compatible discs. It is known to work with Philips CDD-521 and CDD-522, Kodak 522, and Yamaha CDR100 writers. A source code distribution of cdwrite is available. It is written in C and can be compiled on most UNIX flavors. It is documented in a man page. A X front-end for this and the related mkisofs program is X-CD-Roast. [http://sunsite.unc.edu/pub/Linux/utils/disk-management/]

 

ce
A full-screen X Window based editor. The features include multiple editing sessions, rectangular cut and paste, command macros, vertical and horizontal scrolling, and global bounded search and replace. [ftp://ftp.std.com/ftp/vendors/ETG/]

 

CEA Miscellaneous Utilities
A collection of miscellaneous utilities and libraries for UNIX platforms. This collection includes: A source code distribution is available which has been compiled on Sun and Linux Intel boxes.

[http://www.cea.berkeley.edu/~pubinfo/html/CEA_freeware.html]

  

Cecil/Vortex
Cecil is a purely object-oriented language intended to support the rapid construction of high quality, extensible software. It incorporates multi-methods, a simple prototype-based object model, a mechanism to support a structured form of computed inheritance, module-based encapsulation, and a flexible static type system that allows statically- and dynamically-typed code to mix freely. It was developed to maximize the ability to quickly develop software and to reuse and modify existing software, and as such is based on a pure object model wherein all data are objects and objects are manipulated solely via message passing. It includes a general form of dynamic binding based on multiple dispatching to facilitate the message passing. A Cecil standard library defines a collection of data and control structures used by most Cecil programs. The library is conveniently divided into five sections. The first includes basic data types such as void, int, float, char, pair, and triple. The second contains basic control structures such as bool and closure data types and if and while control structures. The third part consists of collections including arrays, sets, hash tables, strings, lists, etc. The fourth part includes streams and file-based I/O operations. The last part is a mixed bag containing some system operations as wel as some other data types and operations.

Vortex is an optimizing infrastructure for object-oriented and other high level languages. It is a language-independent optimizing compiler back-end with front-ends for Cecil, Java, and C++. It performs whole-program analyses by tracking intermodule dependencies in a program database which enables it to determine which compiled files must be recompiled after a programming change. The compiled code and libraries for each program are tuned to that application and cannot be shared with other applications. Vortex compilation occurs in three phases. In Phase Zero, the Vortex front-end translates non-Cecil programs in a Vortex RTL intermediate language. Phase One sees the RTL or Cecil sources translated into either C++ or assembly code. In Phase Two a C++ compiler or an assembler translates this output into object files and an executable.

Binary distributions of the Cecil/Vortex package are available for several platforms including Linux Intel. A large amount of documentation is available in various forms including user's manuals and technical reports.

[http://www.cs.washington.edu/research/projects/cecil/cecil/www/cecil-home.html]

 

Cecilia
A music and sound production system which uses Csound as its sound processing language. The principal goal of Cecilia is to enhance sound production by proposing a powerful design interface and a number of fast tools in an integrated environment in which a Csound tasks will enjoy a large productivity boost. It was designed to address Csound problem areas such as real-time interaction, the specification of time-varying functions, the interplay of Csound with other vital production functions (e.g. formatting, playing, and editing audio files), referencing on-line documentation, and the specification of complex scores. The features of Cecilia include: a number of graphical objects to specify control data for Csound orchestras; a text editor with a number of built-in functions to improve orchestra and score design; the integration of all currently defined Csound functions under menus, buttons, and hot-keys; documentation in the form of interactive manuals with automatic opcode entry; real-time control slider and option boxes; complete file type rules and icons; colorized orchestra keywords; full search and replace; a number of prefabricated modules to accomplish generic sound processing functions such as delays, reverbs, flangers, stretchers, resonators, etc.; a scratch editor; record and loop-record from the outside world; and more.

Cecilia is written entirely using Tcl/Tk and currently (7/97) is available in executable form for SGI IRIX and Linux Intel platforms.

[http://www.musique.umontreal.ca/CEC/]

 

Cellular
The Cellular system for simulating cellular automata consists of a programming language Cellang, an associated compiler cellc, an abstract virtual cellular automata machine avcam, and a viewer cellview. Compiled Cellang programs can be run with input provided at any time during execution, and the results can either be directly viewed or written to an external file and later viewed using cellview. Cellang combines the classic cellular automata programming paradigm with that of agents which allows a richer solution space to many interesting problems. Additional Cellang features include: any number of dimensions; the compile time specification of the size of each dimension; cell neighborhoods of any size and shape; positional and time-dependent neighborhoods; associating multiple values (fields), including arrays, with each cell; associating a potentially unbounded number of mobile agents with each cell; and local interactions only.

The Cellular distribution is available as source code written in C and can be installed on most generic UNIX platforms. The graphical interface portions can be compiled using either standard X Window System calls or the IRIS Graphics Library. It can also be compiled for multithreading support on Sun and SGI machines. The documentation includes a tutorial and a Cellang reference manual, both of which are available in LaTeX format.

[http://www.cs.runet.edu/~dana/ca/cellular.html]

 

Cephes
A software library of more than 400 high quality mathematical routines for scientific and engineering applications, all written entirely in C. Many are supplied in six different arithmetic precisions, i.e. 32-bit single, 64-bit IEEE double, 64-bit DEC, 80- or 96-bit IEEE long double, and extended precision formats having 144-bit and 336-bit significands. About 180 different mathematical functions are covered, including elementary arithmetic and transcendental routines, probability integrals, Bessel functions, and higher transcendental functions. There are complex variable routines covering complex arithmetic, logarithms and exponentials, and trigonometric functions. A simple, common error handling routine is supplied with error conditions producing a display of function name and error type. Several source code distributions of Cephes are available in the various precisions described above. Each distribution contains the basic routines as well as some example applications written with them. They are all written in C and documented via man pages included in each distribution package. The primary documentation for the functions is Moshier (1989).

[http://www.netlib.org/cephes/index.html]
[http://sunsite.unc.edu/pub/Linux/devel/lang/c/ ]

 

CERNLIB
A collection of independent Fortran callable libraries and complete programs developed for and used by CERN and its affiliates for the analysis and presentation of various types of data. If you are a member of one of the abovementioned groups then the programs are freely available by request, but if you aren't an affiliate then you have to pay a yearly fee to use the software. The last time I checked the fee was about $1000 for academic groups. All the programs and libraries are available as binaries for many types of platforms, including Linux. The given URL links to a site containing descriptions of the library components. I'm fairly sure that you can freely obtain the manuals for the various components in PostScript format. [http://wwwcn.cern.ch/pl/cernsoftware]

  

cfengine
A language designed for testing and configuring heterogeneous UNIX-like systems attached to at TCP/IP network which resulted from a research project to help solve the problems of system administration in a big network. The main purpose of cfengine is to allow you to create in an intuitive way a single, central system configuration which will define how every host on a network should be configured. It runs on every host and parses one file (or set of files) with the configuration of the host checked against the file. The sysadmin is either warned about any deviations or they are automatically fixed. Cfengine follows a flexible class-based decision structure which allows a specific group of hosts to be singled out with a single statement. It focuses on tasks that are difficult to handle with scripts of various types. The tasks that can be automated with cfengine include: checking and configuring the network interface, editing text files, making and maintaining symbolic links including multiple links from a single command, checking and setting the permissions and ownerships of files, deleting junk files, systematic and automated mounting of NFS systems, checking for the presence of important files and file systems, and controlled execution of user scripts and shell commands.

A source code distribution of cfengine is available. It is written in C and can be compiled and installed on a variety of UNIX flavors via the supplied configure script. It is documented in a user's manual available in PostScript format.

[http://www.iu.hioslo.no/~mark/cftop.html]
[http://www.gnu.ai.mit.edu/order/ftp.html ]

 

C4
The Canonical Classes for Concurrency Control is a library of C++ classes which assist in parallel programming. C4 allows the programmer to express parallel programs using high level abstractions for a variety of useful operations. Object classes are provided which implement a variety of synchronization and data transmission paradigms. With these classes some important communication patterns can be handled via C++ objects rather than by having to explicitly code every single interaction between processing nodes with message passing calls. C4 will work on either a multicomputer or a network of workstations running either MPI or NXLib. The C4 package is built on top of and therefore requires the use of the DS++ library package. It can be compiled using either Cfront or g++. It is documented in a FAQ and man pages included with the distribution.

[http://dino.ph.utexas.edu/~furnish/c4/c4.html]

 

CFS-C
A package of subroutines and data structures which can be used to implement learning classifier systems for arbitrary, user-defined task domains or environments. The CFS-C routines implement the core, domain-independent parts of a classifier system including routines to implement the steps of the cycle of a classifier system: comparing messages to classifiers and record all matches; calculate bids, run a competition, generate new messages by activating the winning classifiers; and apply the bucket-brigate algorithm, a learning mechanism that redistributes strength to classifiers which tend to lead to useful system behavior. The package also includes subroutines which implement learning algorithms that discover new and potentially useful classifiers, e.g. genetic algorithms. A simple, well-defined interface between the core classifier system and the domain-dependent parts of the system is provided. The CFS-C package includes subroutines which implement a command processor which acts as an interface between a user and the system. It provides ways to: run the major cycle of the classifier; load messages and classifiers from files into the system's message and classifier lists; display the contents of the message and classifier lists; display and set the values of various system parameters; produce a log of a session; save the complete state of the system in a file; and restart the system from a saved state file. CFS-C is not a standalone program that can be run but rather a package of subroutines which must be linked to the subroutines and data structures which implement a specific task or environment. Two such environments are included in the CFS-C distribution: LETSEQ, a system that involves learning to predict letter sequences; and FSW, a system that involves learning to traverse a finite state world.

A source code distribution of CFS-C is available. It is written in ANSI C to be portable to a wide variety of systems, including UNIX platforms. Documentation is available for the CFS-C package as well as the included LETSEQ and FSW programs in TeX DVI format.

[ftp://ftp.cs.wayne.edu/pub/EC/CFS/src/]

 

CFS-C XV
An updated and extended version of CFS-C. [ftp://ftp.cs.wayne.edu/pub/EC/CFS/src/]

 

CG
The Conjugate Gradient package is a library of iterative solution methods for linear systems of equations on distributed processors connected via the PVM library. The iterative methods available in CG include conjugate gradient (CG), CG on normal equations, minimum residual, bi-CG, quasi-minimum residual, non-symmetric CG, generalized minimum residual (GMRES), CG squared, and bi-CG stabilized. A source code distribution of CG is available. It is written in C and is configured to compile and install on most UNIX flavors to which PVM has been ported. A graphical interface created using Tcl/Tk is included along with a stand-alone demo program. The CG library links with some LAPACK and BLAS routines which are included in the distribution.

[http://www.netlib.org/linalg/]

 

CGAP
The Channel Geometry Analysis Program permits the analysis, interpretation, and quantification of the physical properties of an open channel reach as defined by a sequence of cross-sections. CGAP primarily computes the area, width, wetted perimeter, and hydraulic radius of cross-sections at successive increments of water surface elevation (i.e. stage) from data consisting of coordinate pairs of cross-channel distances and land surface or channel bottom elevations. Also computed are longitudinal rates of change of cross-sectional properties as well as the mean properties (including discharge as computed using the Manning's equation) of a channel reach and the cross-sectional area and channel widths as functions of stage for subdivisions of a cross-section. CGAP was developed to compute, display, and format cross-sectional data for use with simulation models, especially for BRANCH and HSPF. A source code distribution of CGAP for UNIX platforms is available. The primary documentation is contained within Regan and Schaffranek (1985). This is part of the USGS Water Resources Applications Software collection.

[http://water.usgs.gov/software/cgap.html]
[http://www.geogr.uni-jena.de/software/cgap.html ]

 

CGI
The Common Gateway Interface is a standard for interfacing external applications with information servers, e.g. HTTP or Web servers. While a plain HTML document is static, a CGI program is executed in real-time and can output dynamic information. CGI programs are usually written in C, C++, Perl, , Python, or in any number of less common languages. They can be binary executables (as is usually the case with C or C++) or scripts which invoke interpreters for scripting languages (the case with Perl, Tcl/Tk, and Python).

CGI programs can be written from scratch using any of the above languages, or developed with the use of various CGI libraries such as cgic, CGIperl, and libcgi++. See also FastCGI and CGIWrap. See Deep (1996), Gundavaram (1996), Boutell (1996), and Brenner and Aoki (1996).

[http://www.cgi-resources.com/ ]
[http://www.itm.com/cgicollection/ ]
[http://www.extropia.com/Scripts/ ]
[http://hoohoo.ncsa.uiuc.edu/ ]

 

cgic
An library of ANSI C routines for CGI programming. The cgic library can perform such tasks as: parsing form data and correcting for defective and/or inconsistent browsers; transparently accepting both GET and POST form data; handling line breaks in form fields in a consistent manner; providing string, integer, floating-point, and single- and multiple-choice functions to retrieve form data; providing bounds checking for numeric fields; loading CGI enviroment variables into C strings which are always non-null; providing a way to capture CGI situations for replay in a debugging environment; providing a safer form of the system() function; and more. The cgic distribution contains the source code, written in ANSI C, and should compile on any compatible compiler, e.g. gcc. Each function is documented online and in documentation provided in the distribution.

[http://www.boutell.com/cgic/]

 

CGIperl
A Perl 5 module set for performing CGI programming. CGIperl includes modules for managing the interface between the application and an HTTP daemon (CGI::Base), handling MIME-type multipart form data (CGI::BasePlus), writing to the HTTP error log (CGI::Carp), building smart HTML forms (CGI::Form), adding the ability to become a mini HTTP server to the Base module (CGI::MiniSvr), and parsing client requests via a CGI interface (CGI::Request). The distribution (which can also be obtained at all CPAN sites and mirrors, is written in Perl 5. Documentation is available in HTML format.

[http://www-genome.wi.mit.edu/WWW/tools/scripting/CGIperl/]

 

cgi.tcl
A CGI support library for Tcl programmers. It supports forms, tables, cookies, file upload, plug-ins, JavaScript, Netscape extensions and much more. It can also be used for generating static HTML, e.g. by storing a link as a Tcl variable for updating several pages simultaneously. [http://expect.nist.gov/cgi.tcl/]

 

CGIWrap
A gateway program which allows general users to use CGI scripts and HTML forms without compromising the security of the HTTP server. Scripts are run with the permissions of the user who owns the script, and several security checks are performed on the script which will not be executed if any checks fail. CGIWrap is used via a URL in an HTML document. It is written in C and installation is made easier via the inclusion of a configuration script with the distribution. [http://www.umr.edu/~cgiwrap/]

 

CGM
The Computer Graphics Metafile is a machine and operating system independent interchange format which provides elements to represent geometric and raster graphics. It is primarily intended for vector-based images but can also be used with raster-based images. CGM is a static picture-capture metafile standard, i.e. it contains no functions with dynamic effects on partially defined pictures. It consists of a functional specification and multiple encodings for different purposes. The three standard encodings for CGM are clear-text, character, and binary. The first is readable ASCII, the second compacted ASCII, and the third binary.

 

CH
An interpreter which implements a superset of C. CH is a very-high level language (VHLL) that can be used for shell programming, CGI programming, distributed network computing, scientific computing, the real-time control of mechatronic systems, and many other applications. The shell environment can be used in regular, restricted, and safe modes. The restricted mode disallows actions such as redirecting output, changing directories, etc., with the safe mode additionally disallowing the declaration of pointers, the casting of pointer types, etc. CH retains most of the C features needed for scientific computing as well as some handy extensions. Metanumbers are available to represent Inf, -Inf, NaN, -0.0 and 0.0, allowing the use of the IEEE-754 arithmetic standard, and they are extended to commonly used mathematical functions. The capabilities of bitwise, assignment, address and indirection, increment and decrement, and type conversion operations are extended from what is available in ANSI C. The Common Gateway Interface (CGI) and Common Client Interface (CCI) are both implemented in the CH language and available in the distribution. CH can be used for distributed computing across the Web. Remotely located programs, i.e. applets, can be downloaded from a server and executed a the client or host computer. Secure features have been built into the language to protect a system from attack, e.g. the C pointer declaration is disabled for applets obtained under a safe shell.

Binary distributions of the CH package are available for several UNIX flavors including Linux Intel. The package includes the three shells under which CH can be run, the CGI and CCI implementations, and many examples of its use. Documentation includes a user's manual, several technical reports, and a set of man pages.

[http://iel.ucdavis.edu/CH/]

 

Chaos Classes
A collection of C++ classes for use in the study of dynamical systems. These are divided into four major categories. The descriptive classes include: The analysis classes include: The straddle routines include: The support classes include: A source code distribution is available.

[http://www.glue.umd.edu/~dsweet/Classes/]

 

CHARM
A machine independent parallel programming system which allows programs written using it to run unmodified on MIMD machines with or without a shared memory. CHARM provides high-level mechanisms and strategies to facilitate the task of developing highly complex parallel applications. CHARM programs are written in C with some syntactical extensions. It is also possible to interface to other languages such as Fortran using the language interfaces provided. Charm++ is a C++-based parallel object-oriented language with all the features of CHARM plus multiple inheritance, late bindings, and polymorphism. The CHARM distribution includes Converse, a framework for interoperability across parallel languages and support for building runtime systems for new parallel languages. The capabilities of this are demonstrated via the inclusion of some other parallel languages in the distribution including: a demo language which supports multiple threads per processor and simple message passing, parallel Java, a subset of PVM, a Futures library, and a message-driven extension of Perl called mdPerl. Tools included in the distribution include: DagTool, which allows the specification of dependencies between messages and sub-computations within a single process to provide a pictorial view of the dependence graph; Projections, a performance visualization and feedback tool; and SummaryTool, a simple performance analysis tool.

Binary distributions of the CHARM system are available for several platforms including Linux Intel. Programs written on any platform are portable to any other platform. Documentation is available in PostScript format for each part of the CHARM system.

[http://charm.cs.uiuc.edu/]

 

Chautauqua
An experimental workflow system whose design focuses on dynamic change and exception handling. Chautauqua is implemented as a client/server application using the Python-based Paos package. [http://www.cs.colorado.edu/~carlosm/chautauqua.html]

 

Checkbot
A tool for verifying links on a set of HTML pages. It can check a set of documents on a single server or on a set of servers. It creates a report which summarizes all links which prompt either an error or warning message. This is written in Perl and requires version 5.002 and the libwww-perl package. [http://dutifp.twi.tudelft.nl:8000/checkbot/]

 

Checker
A GNU tool which finds memory errors at runtime. The primary function of Checker is to emit a warning when the program reads an unitialized variable or memory area or when it accesses an unallocated memory area. It has a Malloc library that issues warnings when free or realloc is called with a pointer that hasn't been obtained from malloc, calloc or realloc, or when free or realloc is called with a pointer that has been previously freed. Checker also implements a garbage detector that can be called either in your program, by a debugger, or on exit from the program. The garbage detector displays all the memory leaks along with the functions that called malloc. A source code distribution of Checker is available. It can be installed via the usual GNU tools. The documentation is also available in the usual GNU format.

[http://www.gnu.org/software/checker/checker.html]

 

Cheney-Kincaid
A series of example Fortran programs from a textbook on numerical mathematics, i.e. Cheney and Kincaid (1985). The algorithms/topics implemented in these programs include the bisection method, Newton's method, Simpson's rule, Gaussian elimination, tridiagonal and pentadiagonal solvers, cublic splines, Euler's method, Runge-Kutta-(Fehlberg) methods, random numbers, Monte Carlo methods, Adams-Moulton method, shooting methods, Crank-Nicholson method, Gauss-Seidel method, and several more.Monte Carlo methods, Adams-Moulton method, shooting methods, Crank-Nicholson method, Gauss-Seidel method, and several more. The codes are deliberately uncommented to force the user to study the code and the book. [http://www.netlib.org/cheney-kincaid/index.html]

 

CHIMP
An implementation of MPI developed at the Edinburgh Parallel Computing Center. This one is a bit dated since the last update was in 1995. [ftp://ftp.epcc.ed.ac.uk/pub/chimp/release/]

 

Chipmunk
A collection of tools for performing a wide variety of tasks including electronic circuit simulation and schematic capture, graphics editing, and curve plotting. The major Chipmunk tools include: A series of supplementary programs are for converting Chipmunk format files to and from other popular formats. A source code distribution is available and has been compiled on several platforms including Linux Intel. Documentation is scattered about in various packages in various formats.

[http://www.pcmp.caltech.edu/chipmunk/]

 

CHPP
The CHakotay PreProcessor is a preprocessor originally designed for HTML which can be applies to nearly any use. CHPP combines the features of cpp, m4, Perl, and Scheme and, according to the authors, is still fairly simple. The features include: it is non-intrusive, i.e. you can take existing text, pipe it through CHPP, and it probably won't change it; user-defined macros which can be recursive; complex data structures such as lists and hashes; regular expression matching; and powerful loop constructs.

A source code distribution of CHPP is available. It is written to be portable and should compile and run on almost any UNIX platform. A reference manual is available.

[http://chakotay.ml.org/]

 

Cicero
A word processor with a font installer that installs PostScript Level 1 fonts in X, ghostscript, TeX and Cicero native format. It is written in C++ and runs on UNIX/X Window systems, and also requires Motif. 2.0. The sources are available as well as a statically linked binary. There is no documentation as yet but it is said to be "on the way". [http://zeus.informatik.uni-frankfurt.de/~weis/cicero.html]

 

CIF
The Crystallographic Information File is a general, flexible, and easily extensible free-format archiving standard for crystallographic data. It is human and machine readable and can be edited with a text editor. It was designed for the electronic transmission of crystallographic data between laboratories, journals and databases. The file consists of data names and data items together with a loop facility for repeated items. The sorted list of data names, together with the precise definitions, constitutes the CIF Dictionary, which contains the fundamental and most commonlyused data items relevant to crystal structure analysis. [http://www.iucr.ac.uk/cif/home.html]

 
CIFLIB
A C class library developed to provide an application program interface to macromolecular data in CIF format. A source code distribution is available as is a reference manual in HTML and PostScript format. [http://www.iucr.ac.uk/iucr-top/cif/mmcif/ndb/software/CIFLIB/index.html]  
Xtal_GX
A program designed primarily to read and write crystal structure information in the form of CIFs. It can be used to validate CIFs against the CIF Dictionary. In addition to parsing CIFs, it also extracts symmetry and structural information for display, manipulation and plotting purposes. Additional routines assess the structure for unrecognized symmetry elements in the structure which can also be graphically represented. Binary distributions are available for several platforms including Linux Intel. A user's guide is available in PostScript format. [http://www.iucr.ac.uk/iucr-top/cif/software/xtal/gx/index.html]

 

CIFS
The Common Internet File System is a standard remote file system access protocol for use over the Internet. It is an open, cross-platform technology which is an enhanced version of Microshaft's Server Message Block (SMB) protocol, the native file-sharing protocol in the Microshaft operating systems. The chief enhancement is that CIFS runs over TCP/IP and uses the DNS for scalability. It is also optimized to support slower speed dial-up connections. It is designed to complement HTTP while providing more sophisticated file sharing and transfer than older protocols such as FTP. It is also designed to allow all applications to open and share files securely across the Internet. The Samba package implements CIFS. [http://www.microsoft.com/intdev/cifs/]

 

Cilk
An algorithmic multithreaded language whose philosophy is that the programmer should concentrate on structuring his program to expose parallelism and exploit locality and leave the runtime system with the responsibility of scheduling the computation to run efficiently on a given platform. As such the Silk runtime system handles load balancing, paging and communication protocols. It differs from other runtime languages in that its runtime system guarantees efficient and predictable performance. The distribution contains a runtime system and the Clik2C compiler, a type-checking preprocessor that translates Cilk into C. The most recent version, 4.0, is configured for Sun Solaris SMPs (Symmetric Multi-Processors) as well as SGI SMPs, and a version for distributed memory machines (such as networks of workstations) is expected by Fall 1996. An earlier version, i.e. 2.0, is still available which already works on vanilla UNIX machine networks, including Linux. Documentation is available in the form of user's manuals for the various versions and several technical reports, all in PostScript format.

[http://theory.lcs.mit.edu/~cilk/]

 

cim
A compiler for the Simula language (except for unspecified parameters to formal or virtual procedures). It offers a class concept, separate compilation with full type checking, an interface to external C routines, an application package for process simulation, and a coroutine concept. A source code distribution of cim is available. The compiler and the run-time system are written in C and the compiler produces C code that is compiled using the platform's native C compiler. A user's manual is included in several formats.

[ftp://ftp.ifi.uio.no/pub/cim/]
[http://www.ifi.uio.no/~cim/cim_toc.html ]

 

Cineast
A browser written in an extension of Tcl/Tk called OTcl. It uses the Wafe toolkit to implement the user interface, especially the Kino widget class which provides a callback interface for HTML parsing and arbitrary widgets as insets. Cineast supports most of HTML 3.2 and also features incremental parsing and rendering. Secure connections are possible via an interface to SSLeay. A source code version is available as is a binary for Linux Intel platforms (either statically or dynamically linked to Motif). [http://nestroy.wi-inf.uni-essen.de/wafe/Cineast/]

 

CINEMA
The Color INteractive Editor for Multiple Alignments is a package for the visualization and manipulation of both protein and DNA sequences. CINEMA allows the interactive building of alignments using either a free-format cut and paste facility to import sequences or by adding sequences directly from a database. Alignments are edited by clicking on a sequence and dragging it to create gaps. The functionality of the package includes:

A source code distribution of CINEMA is available. It contains the Java classes, HTML, and Perl scripts needed to set up and maintain an installation. Extensive documentation is available in HTML format.

[http://www.biochem.ucl.ac.uk/bsm/dbbrowser/CINEMA2.1/]

 

Citadel/UX
A BBS for UNIX platforms. The features of Citadel/UX include: A source code distribution is available which requires pthreads on Linux platforms.

[http://uncnsrd.mt-kisco.ny.us/citadel/]

 

C-Kermit
Kermit is a file transfer protocol developed specifically for the error-free transmission of text and binary files between diverse types of computers over noisy communications links. It is also a suite of communications software programs. The Kermit protocol incorporates file group transmission, file attribute transmission, file collision options, file transfer recovery, automatic upload and download, client/server operations, uniform services on serial and network connections, and file name, record-format, and character-set conversion. The major features of the Kermit software include: connection establishment and maintenance for a wide variety of connection methods, e.g. dialup, TCP/IP, LAN, etc.; terminal emulation; error-free file transfer; character-set translation during both terminal emulation and file transfer; and script programming to automate complicated or repetitive tasks. The user interface and script programming language are consistent across all supported platforms. The software is designed for robustness, i.e. is assumes that anything that can go wrong probably will go wrong. This allows it to work the first time almost every time. The reliability can be at the expense of speed, although given a good connection Kermit can be as fast as other popular protocols after a few (3) parameters have been adjusted appropriately.

The version of Kermit which works on UNIX platforms is called C-Kermit, which is available in source code format as well as in binary form for a wide range of UNIX flavors. Quite a bit of documentation is available online, but the chief documentation source is a commercially available manual whose sales provide the only source of funding for further development. See da Cruz (1997).

[http://www.columbia.edu/kermit/]

 

CLAIRE
A high-level functional and object-oriented programming language with advanced rule processing capabilities intended to allow programmers to express complex algorithms in a manner that is pithy, elegant, and readable. The features that enhance expressivity include a rich type system including type intervals and second-order types (with dual static/dynamic typing), parametric classes and methods, an object-oriented logic with set extensions, and dynamic versioning which supports the easy exploration of search spaces. Readability is enhanced by such features as set-based programming with an intuitive syntax, a simple style of object-oriented programming, truly polymorphic and parametric functional programming, a powerful and readable extension of DATALOG to express logical conditions, and a entity-relation approach with explicit relations, inverses, unknown values, and relational operations. CLAIRE is a complete programming system with an interpreter, a compiler, and several tools including a tracer, a debugger, and an object inspector. It can also be used as a C++ pre-processor since it generators human-readable C++ code, and the interpreter can be used as a query langauge because of its logic and set capabilities. Additional features include a simple GUI implemented with Tcl/Tk, an Emacs mode for editing source files, and a library for solving scheduling problems.

A source code distribution of CLAIRE is available. It is written in C and can be compiled and installed on most UNIX flavors via the autoconf script provided in the distribution. The package is documented in a user's manual available in PostScript format.

[http://www.ens.fr/~laburthe/claire.html]

 

classifier systems
Special types of message processing, rule-based production systems in which many rules can be simultaneously active and therefore can be processed in a parallel way. A classifier system consists of four basic parts: a classifier list consisting of a set of condition-action rules called classifiers; a message list which acts as a blackboard for communications and short term memory; an input interface which provides the classifier system with information about is environment; and an output interface which provides a way for the classifier system to communicate with or change its environment.

A classifier system is run by repeatedly executing a series of steps: add the messages generated by the input interface to the current message list; compare all messages on the message list to the condition-parts of all classifiers and record all matches for classifiers that have their condition-parts satisfied; generate new messages by activating each classifier that has its condition-part satisfied; process the new messages through the output interface; and replace the contents of the message list with the new messages; The basic classifier system has no way to learn, but this capability can be introduced by either: changing the major-cycle so that the activation of each classifier depends on some additional parameter that can be modified as a result of experience; or changing the contents of the classifier list by removing classifiers, adding new ones, or changing the conditions or action-parts of existing classifiers.

Packages which implement classifier systems are: CFS-C, CFS-C XV, and REGAL.

 

CLAWPACK
A collection of Fortran subroutines for solving hyperbolic systems of conservation laws in one and two space dimensions, both with and without source terms. High resolution flux-limiter finite volume methods are used on uniform rectangular grids. In two dimensions an unsplit multidimensional algorithm using transverse wave propagation has been implemented. A variety of example problems are is included in the package, which is intended both for research and instructional purposes. A nice selection of documentation in PostScript format is available. This can also be accessed at the Netlib CLAWPACK site. See also the AMRCLAW package. See LeVeque (1997 in press). [http://www.math.washington.edu/~rjl/clawpack.html]

 

Clean
A general purpose, higher-order, pure and lazy functional programming language for the development of sequential, parallel, and distributed real-world applications. The design rules for Clean specify that the semantics must be based on graph rewriting systems, that it must be suitable for writing real-world applications in a compact and readable style, that programs run with an efficiency comparable to C, that direct and efficient interfacing with the non-functional world must be possible, and that a program must be fully portable. Clean features that implement these (and other) design rules include semantics with which one can explicitly define the sharing of structures; strong typing including polymorphic, abstract, algebraic, and synonym types; type classes provided to make the overloaded use of functions and operators possible; predefined types including integers, reals, booleans, characters, strings, tuples, records, arrays, etc.; a polymorphic uniqueness type inferencing system with which one can influence the time and space behavior of programs and efficiently interface to the non-functional world by offering direct access to file and operating systems; a sophisticated I/O library that allows the development of window-based interactive applications; the possibility of dynamic process creation that can be run in parallel or interleaved; and more.

Clean is available in binary form for Mac, MS-DOS/Windows, Linux, SunOS and Solaris systems. The distribution contains a compiler, a code generator, the I/O library, a program development system, and the documentation. The documentation consists of a language report and preliminary chapters of a forthcoming book, both available in PostScript format. See Plasmeijer and van Eekelen (1994).

[http://www.cs.kun.nl/~clean/]

 

CLiCC
The Common Lisp to C Compiler generates C executables from Common Lisp application programs. It is intended to be an add-on to existing Common Lisp systems for generating portable applications. It supports a subset of Common Lisp + CLOS which is called CL_0 (i.e. CommonLisp_0) which is a strcit and very large subset of full Common Lisp + CLOS without EVAL and related constructs. [ftp://ftp.gmd.de/GMD/apply/software/CLICC/]

 

Clif
A C-Like Interpreter Framework is an interpreter for preparing large programs for computer intensive information processing and for control of technological processes. In the Clif framework syntactic and semantic structures are prepared in an open way with expressiveness similar to languages like C or Fortran. The user can then add such structures specific to a given problem to obtain a powerful application directed language. The development of Clif was motivated similarly to the development of Matlab and similar environments, i.e. to have a convenient and open tool for the manipulation of objects in large, optimized scientific computing libraries such as BIGNUM, LAPACK, etc. The Clif structure stresses user interfaces at all levels of the interpreter system, e.g. a user can write procedures within the Clif specification, built modules in different languages, and then link those modules into Clif. The user can even add new language structures to Clif.

The Clif source code, written in C, is included with the package as well as documentation in the form of a programmer's manual and a technical report, both in PostScript format.

[ftp://dec50.vm.stuba.sk/pub/csgrp/packages/clif/]

 

clig
The Command Line Interpreter Generator uses a simple description to generate C code for a function which parses the command line of a typical C program. It takes as input a simple description file and generates standard C which depends only on libc. A source code distribution of clig is available. It is written in Tcl. [http://wsd.iitb.fhg.de/~kir/clighome/]

 

CLiP
A literate programming tool flexible enough to be independent of programming languages and any document formatters. CLiP doesn't use explicit commands to perform the usual extraction process but rather recognizes pseudostatements written as comments in the programming language being used. It distinguishes the pseudostatements from regular comments because the former comply with a set style that can be adjusted to suit most programming languages. CLiP supports a wide range of features found in most text processing systems including the inclusion of drawings, pictures, tables, cross-references, indices, and tables of contents. It can extract any number of modules from a maximum of 64 source files and supports partially specified data types. It does not pretty print but rather copies code from the source files as-is to the module. A source code distribution of CLiP is available. Versions are available for VAX/VMS, DOS, and UNIX platforms. A user's guide is available in PostScript format as are a wide range of examples featuring several languages and output formats.

[ftp://sun01.info.wau.nl/clip/]

 

CLIPS
The C Language Integrated Production System is a language originally designed to provide support for rule-based programming which has expanded to provide support for rule-based, object-oriented, and procedural programming. It is a specialized language for expert systems which differs greatly from commonly used AI languages such as Lisp and Prolog. CLIPS has shells and utility programs specifically designed for creating expert systems. It supports a forward chaining inference technique and can also simulate a backward chaining inference method. CLIPS consists of three fundamental components: facts, rules, and an inference engine. Facts are a combination of data fields which are seldom modified or changed. Rules or knowledge are divided into IF (LHS) and THEN (RHS) portions and are often changed according to new facts and conditions. The inference engine is a cognitive processor and makes references by deciding which rules are satisfied by the facts. Key features of CLIPS include knowledge representation using three different programming paradigms, portability, capabilities for integration (via embedding) and extensibility, interactive development via a text-oriented environment with debugging aids and an editor, verification and validation via a number of features, and extensive documention. CLIPS can be easily ported to any system with an ANSI C compiler, for instance a Linux box with the GCC compiler. The given site contains source code, ancillary packages and documention for CLIPS. See also FuzzyCLIPS, JESS, and KAPICLIPS.

[ftp://ftp.cs.cmu.edu/user/ai/areas/expert/systems/clips/0.html]
[http://www.ghg.net/clips/CLIPS.html ]

 

CLISP
A Common Lisp implementation that includes an interpreter, a compiler, a subset of the Common Lisp Object System (CLOS), and a screen editor. Additional packages running on CLISP are also available and described at the site. It runs on microcomputers (DOS, OS/2) as well as on most workstations, including Linux. [ftp://ma2s2.mathematik.uni-karlsruhe.de/pub/lisp/clisp/]

 

CLM
Common Lisp Music is a music synthesis and signal processing package in the Music V family. It includes sound generators, various instruments, examples of note lists, a make facility for sound files, various functions useful in sound file work, and an increasingly useful graphical display capability based on the snd sound editor. The CLM instrument design language is a subset of Common Lisp including its numerical functions and nearly all of its control functions. It has been extended with a large number of sound-related functions. The instruments can be run as Common Lisp or compiled into C code. The source code for CLM is available. It is written in Common Lisp and works on NeXTstep, SGI, Mac, Sun SunOS, and Linux Intel platforms. On the Linux platform the ACL, GLC and CLISP implementations of Common Lisp are known to work with this package. An extensive user's manual in HTML format is included in the CLM distribution. See also the snd sound editor and CMN.

[http://www-ccrma.stanford.edu/CCRMA/Software/clm/clm.html]

 

CLOP
A report and associated software concerning the use of C++ for object-oriented computational geophysics. [http://sepwww.stanford.edu/public/docs/clop/]

 

CLP
An implementation of cu-Prolog, a symbolic and combinatorial constraint logic programming language. CLP was designed to process these kinds of restraints rather than numerical constraints since natural language processing and AI applications generally use the former. The package features a cu-Prolog interpreter written in C, support for Partially Specified Terms (PSTs) for feature structures of constraint-based grammar formalisms, and a constraint solver based on the unfold/fold transformation. A source code distribution fo CLP is available. It is written in C and can be compiled and used on most generic UNIX platforms as well as on Mac platforms. A user's manual is available in LaTeX format. This is part of the ICOT project.

[http://www.icot.or.jp/AITEC/IFS/IFS-abst/009.html]
[http://www.icot.or.jp/AITEC/IFS/list/catalogue-E.html ]

 

CL-PVM
A set of functions that interface Common Lisp (KCL, AKCL, or GCL) to the C-based library of PVM. This interface is complete and allows Lisp-based programs to take part in a PVM arrangement and thus facilitates the combination of symbolic and numerical mathematics, graphics, and other useful systems in a distributed manner. Documentation, on-line manual pages, and examples are included in the distribution. Both PVM and the Common Lisp distributions indicated have ports to Linux platforms. [ftp://ftp.mcs.kent.edu/dist/wang/]

 

clusfind
A set of six programs for performing cluster analysis. The programs are: DAISY, which computes dissimilarities; PAM, which partitions a data set into clusters with a method using medoids; CLARA, for clustering large applications; FANNY, which performs fuzzy clustering; TWINS, which performs hierarchical clustering with a choice between agglomerative and divisive methods; and MONA, which performs divisive hierarchical clustering of binary data sets. The source code for all of the programs in clusfind is available. It is written in Fortran 1977 and documented in Kaufman and Rousseeuw (1990).

[http://lib.stat.cmu.edu/general/]

 

Clustal V
A molecular biology program for performing multiple sequence alignments. It is written in C and can be compiled on most platforms. [ftp://ftp.bio.indiana.edu/molbio/align/clustal/]

 

Cluster
A program for performing cluster analysis on an arbitrary set of vectors. The cluster analysis algorithms implemented include Ward's minimum variance method, single linkage, complete linkage, group average, McQuitty's method, Gower's median method, and the centroid method. A source code distribution is available. It is written in C. [http://www.biochem.ucl.ac.uk/~martin/programs/index.html]

 

CLUSTER
A library of several dozen Fortran 77 routines for performing various multivariate clustering algorithms. The routines in CLUSTER include: and many other programs to perform various basic statistical and linear algebra tasks.

The programs in CLUSTER are all written in Fortran 77. There is some documentation for each program within the source code, and the codes were originally produced for Hartigan (1975). This is part of CMLIB.

[http://lib.stat.cmu.edu/cmlib/src/cluster/]

 

Clusters
A collection of Matlab routines to perform various clustering tasks using k-means clustering. [http://www.cs.cmu.edu/People/dellaert/software/]

 

CMAT
An exact arithmetic calculator program designed to perform many of the standard arithmetical operations that can be carried out exactly (i.e. without approximations) on matrices and polynomials whose coefficients are either rational numbers, complex rational numbers, or elements of the finite field of p elements where p is a prime number less than 65536. Several routines are available for operating on polynomials and rational, complex or mod p numbers. A great number of matrix calculation and manipulation routines are available including those for:

A source code distribution of CMAT is available. It is written in ANSI and portable to most UNIX platforms with an appropriate compiler. Some sparse documentation is available online as well as in the distribution.

[http://www.maths.uq.edu.au/~krm/krm_cmat.html]

 

CMIP
The Common Management Information Protocol was a planned successor protocol to SNMP in the late 1980s. CMIP was better organized and contained more features than did SNMP, but has not become popular mainly because it runs under the OSI network communication protocol, which has itself not superseded TCP/IP as was planned. An implementation of CMIP called Webbin' CMIP is available for Linux platforms. [http://www.inforamp.net/ kjvallil/t/snmp.html]
[http://netman.cit.buffalo.edu/index.html ]

 

CMLIB
A collection of non-proprietary and easily transportable Fortran subroutine packages which solve a variety of mathematical and statistical problems. This was originally compiled for the National Bureau of Standards (NBS, now the NIST) and has also been called the NBS Core Math Library. Each sub-library in CMLIB is available as individual source files or as a shar archive of all the files in the sub-library. There is also a shar archive of all the other CMLIB routines required for each sub-library. The documentation is handled similarly. The packages which comprise the library are:

Each sub-library is described and can be obtained via its separate entry in this catalog. All the libraries are written in Fortran 77 which may possibly have some non-canonical extensions.

[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
[ftp://ftp.nist.gov/pub/cmlib/ ]

 

CM
Common Music is an object-oriented music composition environment which produces sound by transforming a high-level representation of music structure into a variety of control protocols for sound synthesis and display, e.g. MIDI, Csound, CLM, Music Kit, C Mix, C Music, M4C, RT, Mix and CMN. It defines an extensive library of compositional tools and provides a public interface through which the composer may easily modify and extend the system. All ports provide a text-based music composition editor called Stella. The source code for CM is available. It is written in Common Lisp and can be compiled with ACL, GCL, CLISP, and CMUCL, all of which are available for Linux Intel platforms. The system is extensively documented in several documents in HTML format included in the distribution. The distribution site has several additional related documents. See also snd.

[http://www-ccrma.stanford.edu/CCRMA/Software/cm/cm.html]

 

CMAPF
A library which provides mathematical transformations of conformal maps, i.e. they perform coordinate transformations between points and vectors on the Earth's surface (given in degrees of longitude and latitude) and their equivalents on a class of X-Y grids overlaying conformal maps. The package also supplies routines which supply projection-dependent terms of the governing equations (of meteorological circulation models), wind component conversions, and rotation axis orientation components. The library is available in source code form with versions written in both Fortran and C. It is documented in a technical report available in PostScript format. See Taylor (1997).

[ftp://arlrisc.arlhq.noaa.gov/pub/geography/]

 

CMIX
A library of C functions designed to create and manipulate sound files. The functions are optimized to do sound processing tasks and can be linked with CMIX disk I/O routines and a command parser called MINC (MINC Is Not C) to build a CMIX instrument, i.e. an executable program. MINC is actually a language that can be used to create compositions which allows for the embedding of loop constructs, variables and conditional tests in the scorefile (i.e. the file containing control data for a CMIX instrument. MINC interprets the programming commands in the scorefile and passes the resulting numerical parameters to the correct CMIX functions. CMIX can output sound from files already created or produce ouput in real time. The source code for CMIX, written in C, is available and has been compiled and tested on Linux boxes. The documentation is contained within the source distribution and also available online in HTML format. There is a separate Linux version called RTcmix which features improved real time capabilities.

[http://www.music.princeton.edu/winham/cmix.html]

 

CML
The Chemical Markup Language is a package which extends SGML to the management of chemical information. CML and its associated tools allow for the conversion of current files without semantic loss, structured documents including chemical publications, and the precise location of information within files. While CML requires strict adherence to SGML, it is mostly no more complicated from the user's point of view than HTML. It relies heavily on the use of carefully structured glossaries rather than adding semantics to the language which allows a greater flexibility for adding new terms and even new glossaries without having to revise the language or modify the software. CML extends the range of structured datatypes found in HTML to include: numeric and string data in scalar, array, matrix or tabular form (with the glossaries capable of containing run-time code for the validation or transformation of data items); molecular information including stoichiometry, connection tables, crystallography, symmetry, chirality, atom and bond types, etc. (with sufficient power to represent the common molecular formats chosen in Chemical MIME , a set of chemical extensions for MIME); scientific units in a separate glossary allowing for the development of code for automatic conversion; special files containing, e.g. PDB and SWISS-PROT files for a protein with accompanying hypertext; and provision for chemical reaction and protein sequence information in the testing stages. The CML package is available as source code. It is written in C and Tcl/Tk and thus requires a compiler and the latter package for installation. Other packages required include sgmls, CoST, BLT, and RasMol. The distribution includes a set of DTDs, a large amount of documentation in TeX and HTML format, glossaries to add semantic content to CML documents, supporting material for HTML 2.0, several examples, and CMLCOST, a browser for CML files created using the CoST package.

[http://www.seqnet.dl.ac.uk/CBMT/cml/index.html]

 

CMN
The Common Music Notation package is a western music notation package written in Common Lisp. It requires either the Adobe Sonata or the Finale Petrucci font. It was developed as a hack to provide a way to translate a CLM note list into a traditional score as well as a way to create editable PostScript files for cut and paste operations. The CMN source code is available. It is written in Common Lisp and works on NeXT, SGI Indigo, NeXTStep/OpenStep, Mac II, Mac PowerPC, and Linux Intel systems. It can be used on Linux platforms with ACL, CMUCL, CLISP or GCL. The package is documented in a user's manual in HTML format included in the distribution. See also snd and CM.

[http://www-ccrma.stanford.edu/CCRMA/Software/cmn/cmn.html]

 

CMT
The Continuous Media Toolkit is a toolkit for multimedia applications. It is built on top of the scripting language and GUI toolkit Tcl/Tk and the network tools package Tcl-DP. It is implemented as a collection of objects, each of which handles a specific task, e.g. reading MPEG encoded video from a file or decoding and displaying MPEG encoded video. Other objects exist which support the construction of distributed applications, transmit and receive data using the Real-time Transport Protocol used by the MBONE tools, transmit and receive data across a TCP/IP network using Cyclic-UDP, filter uncompressed video, and display video on the experimental InfoPad . CMT supports several audio and video encoding formats, including Sparc style audio, MPEG video, MJPEG video, and H.261 video. It also contains support for a number of audio interfaces including the Sparc, Linux and Irix devices as well as DEC's AudioFile. It contains software MPEG, MJPEG and H.261 decoders as well as the capability to perform hardware assisted decompression using the Sun Parallax, SunVideo, DEC J300 or SGI Cosmo board. It also comes with the CMplayer, a sample application that can be used to play audio and video files locally or from a CMT video file server. The CMT source code is available and compiles under most versions of UNIX and Windows NT. It has been compiled and tested on DEC Alpha, HP 700, Sun SPARC, Linux, SGI and Windows NT platforms. The documentation is included in the source distribution and is also available online in HTML format.

[http://bmrc.berkeley.edu/projects/cmt/]

 

cmtools
Renamed to ivmkcm.

 

CMUCL
The CMU version of Common Lisp. This distribution includes an incremental compiler, the Hemlock Emacs-style editor, source code level debugger, and code profiler. It is mostly X3J13 compatible including the new loop macro. The python compiler is more sophisticated than other compilers and produces better code. It performs many optimizations that are absent or less general in other compilers, and is particularly good at number crunching. Other compiler features include good type checking and efficiency at the same time, type declarations are verified in safe code, full source level debugging of compiled code including display of the exact call that got an error, and block compilation, partial evaluation, lightweight functions and proper tail-recursion which allow the low cost use of function call abstraction. Compiler optimizations include interprocedural type inference, global flow analysis, dynamic type inference, global register allocation, stack number allocation, control optimization, integer range analysis, enhanced inline expansion, multiple value optimization, and source-to-source transforms. CMUCL features which make it good for number crunching include: good inline coding of float and 32-bit integer operations with no number consing, full support for IEEE single and double precision numbers, numbers are passed as function arguments and return values in registers in block compiled code, calls to library functions are optimized to a direct call to the C library routine, and substantially better bignum performance than commercial applications. There are over 50 pages in the user's manual describing the numerical capabilities of CMUCL. The debugger features: Motif-based and command-line interfaces, commands to print the precise original source form responsible for an error, access by name to variables in compiled code, stepping of compiled code, and integration with the Hemlock editor.

The CMUCL distribution is available either as source code or in binary form for several platforms including Linux Intel. It's not a good idea to attempt to compile from source unless your're a mongo wizard. The documentation includes a 150 page user's manual and a 125 page Hemlock user's manual, both of which are available in PostScript.

[ftp://ftp.cc.gatech.edu/pub/linux/devel/lang/lisp/]
[http://www.cons.org/cmucl/ ]

 

CMU SNMP
An implementation of SNMP which has been ported to Linux. The current, i.e. 8th, release supports SNMPv1 and SNMPv2, and includes a bilingual agent and several simple command-line management tools. It is based on the CMU SNMP release with USEC support. The MIB modules supported in this release are MIB-2, Identification MIB, Host Resources MIB, and an experimental TUBS Linux MIB. The programs and tools in the distribution include: snmpd, the SNMP agent which runs as a background daemon; snmpget, an application which uses the GET request to query for information on a network entity; snmpgetnext, an application which uses the GET NEXT request to query for information on a network entity; snmpnetstat, which symbolically displays the values of various network-related information retrieved from a remote system; snmpset, which communicates with a network entity using SET requests; snmpstatus, which retrieves several important statistics from a network entity; snmptrap, which forms and sends a TRAP message to a host; snmptrapd, which receives and logs TRAP messages sent to the SNMP-TRAP port on the local machine; snmpwalk, which uses GET NEXT requests to query for a tree of information about a network entity; and authkey, which creates an authKey for the managing applications. A source code distribution of the Linux port of CMU-SNMP is available. It can be easily compiled and installed on Linux boxes using the supplied configure script. The applications are documented in a set of man pages.

[http://www.gaertner.de/snmp/]

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z
next up previous contents
Next: Cn-Cz Up: Linux Software Encyclopedia Previous: Bn-Bz
Steven K. Baum
7/16/1998