Next: Da-Dm Up: Linux Software Encyclopedia Previous: Ca-Cm Contents

Cn-Cz

CN: A rule-induction program which takes a set of examples (i.e. vectors of attribute-values) and generates a set of rules for classifying them. It also allows the evaluation of the accuracy of a set of rules in terms of a set of pre-classified examples. The algorithm inductively learns a set of propositional if-then rules from a set of training examples by performing a general-to-specific beam search through rule-space for the best rule, removing training examples covered by that rule, and then repeating the process until no more good rules can be found. The algorithm defines best using the Laplace estimate.
The source code for the CN2 system is available and is written in C. It has been compiled on Sun SunOS and SOlaris, SGI IRIX, HP-UX, and Linux Intel platforms. It is documented in a user's manual in LaTeX format included in the distribution. See also Clark and Niblett (1989).
[http://www.cs.utexas.edu/users/pclark/software.html]
CNCL: The ComNets Class Library is a collection of C++ classes featuring generic C++ classes as well as a simulation library with strong points in random number generation, statistics, and event driven simulation. All classes and definitions feature a prepended CN to avoid collision with other class libraries. There are classes for construct various sorts of queues, creating linked lists and a stack, scheduling events, creating 1-, 2-, and 3-D arrays, creating hash tables, character strings, graphics, fuzzy variables and rules, and many more general and specific tasks.
An abstract random number generator base class CNRNG includes;

CNLCG, a linear congruential generator;

CNMLCG, a multiplicative linear congruential generator;

CNACG, an additive congruential generator;

CNFiboG, a lagged Fibonacci generator;

CNTausG, a Tausworthe generator; and

CNFileG, a data file random number generator.

An abstract random distribution base class CNRandom includes:

CNBeta, a beta distribution;

CNBinomial, a binomial distribution;

CNDeterm, a deterministic distribution;

CNDiracTab, a distribution from a table;

CNDiscUniform, a discrete uniform distribution;

CNErlang, an Erlang-k distribution;

CNGeometric, geometric distributed random numbers;

CNHyperExp, hyperexponential distributed random numbers;

CNHyperGeom, hypergeometric distributed random numbers;

CNMDeterm, a random mix of deterministic distributions;

CNNegExp, a negative exponential distribution;

CNNormal, a normal distribution base class including lognormal, Rayleight and Rice distributions;

CNPoisson, a Poisson distribution;

CNRandomMix, a mix of several CNRandom distributions;

CNUniform, a uniform distribution; and

CNWeibull, a Weibull distribution.

An abstract statistics evaluation class CNStatistics includes:

CNMoments, for evaluation of weighted moments;

CNMomentsTime, for evaluation of time-weighted moments;

CNConfidence, for evaluation of moments with confidence intervals;

CNLRE, a base class for evaluation by LRE F(x);

CNDLREF, evaluation by discrete LRE F(x);

CNDLREG, evaluation by discrete LRE G(x); and

CNBatchMeans, evaluation by batch means.

A source code distribution of CNCL is available. It is written in C++ and can be compiled with GNU g++ and other C++ compilers. A user's and reference manual detailing all of the classes in available in various formats.
[http://www.comnets.rwth-aachen.de/doc/cncl.html]
COAP: A collection of codes associated with papers published in Computational Optimization and APlications. The available programs include:

ADM (92003), an alternating direction method of multipliers to solve separable convex programming problems;

AUCTION (92001), auction algorithms for network flow problems;

BLP (92012), for the generation of disjointly constrained bilinear programming test problems;

box (99001), for the validation of an augmented Lagrangian algorithm with a Gauss-Newton Hessian approximation using a set of hard-spheres problems;

DualAffCode (92010), for the efficient solution of two-stage stochastic linear programs using interior point methods;

ep (93013), an ellipsoid-scaling algorithm using parallel cuts;

LMCOAP (96007), for the resolution of monotone complementarity problems;

LSGRG(MIS) (93018), for analyzing infeasible nonlinear programs;

MPPA (92007), a modified proximal point algorithm for extended linear-quadratic programming;

QGE0L (92006), generates quadratic assignment test problems with known optimal permutations; and

secant (93006), a reduced Hessian methoed for constrained optimization.

[http://www.ici.ro/camo/hco.html]
COAS: The goal of the Caldera Open Administration System project is to improve the way users administer their Linux systems. This will be done by providing a set of tools which have multiple interfaces and which are flexible, powerful, and easy to use. The features of the planned architecture include a framework into which plug-in administration modules called Caldera Loadable Administration Modules (CLAMs) can be installed, with each CLAM consisting of the code and data required to perform a set of related administration tasks. The components comprising each clam are:

a schema definition file which provides a single logical presentation of the data manipulated by a module, with the definition written using a schema definition language;

a mapper, i.e. a piece of code responsible for converting configuration data from its original format and file into that described by the schema definition (and vice-versa);

a configurator, i.e. a piece of code that controls the user interface for manipulating configuration data, using a generic interface API to present menus, dialogs, and screens for screen interaction;

core engine services, i.e. an engine written in C++ which provides data modeling handling and several additional services (e.g. logging, version control, data consistency checks, etc.).

Source code distributions of development versions of COAS (1/98) are available. They can be compiled and used on Linux platforms via the supplied configuration scripts. Full use of the package also requires ncurses, Python, readline, and Qt.
[http://www.coas.org/]
Cobcy: A program which compiles ANSI COBOL sources into readable ANSI C sources. It doesn't support some features like arrays, string operations, and record-record MOVEs. Relative and indexed files are in dBASE III format so a DBF library in included. This was developed on a Linux platform.
[ftp://tsx-11.mit.edu/pub/linux/sources/usr.bin/]
COBOL: A language making a big comeback due to the Year 2000 software problem. Freely available compilers are Cobcy and Deskware COBOL. The given URL is to the COBOL Center.
[http://www.infogoal.com/cbd/cbdhome.htm]
CoCheck: Consistent Checkpoints provides a way to create consistent checkpoints of parallel applications which can be used to migrate processes of the application to new hosts when some of the machines on which the processes are currently running become unavailable. Versions are available that work with PVM and MPI. Although currently (2/99) unavailable for Linux, such as version is promised ``real soon'' at the site. Documentation includes several technical reports.
[http://wwwbode.informatik.tu-muenchen.de/~cocheck/]
Cocktail: A set of program generators or compiler construction tools for nearly all phases of a compiler. The performance is claimed to be quite a bit faster than for the comparable lex and yacc tools. Cocktail consists of several parts. Rex, the regular expression tool, is a scanner generator whose specifications are based on regular expressions and arbitrary semantic actions written in one of the target languages C or Modula-2. Lalr is a LALR(1) parser generator that accepts grammars written in extended BNF notation which can be augmented by semantic actions expressed by statements in the target language. The generated parsers included automatic error recovery, error messages, and error repair. Ell is an LL(1) parser generator which accepts the same specification language as Lalr except that the grammars must be LL(1).
Ast, a generator for abstract trees, generates abstract data types (program modules) to handle trees. The trees may be attributed and nodes may be associated with arbitrarily many attributes of arbitrary type. Specifications are based on extended context-free grammars, and a common notation is used for concrete and abstract syntax as well as for attributed trees and graphs. Other features include:

an extension mechanism providing single inheritance,

trees stored as linked records,

generation of efficient program modules in C or Modula-2,

provision of many tree operations (procedures),

node constructors which combine aggregate notation and storage management,

ASCII and binary graph readers and writers,

top down and bottom up traversal, and

an interactive graph browser.

Ag, an attribute evaluator generator, processes ordered attribute grammars (OAGs) and higher order attribute grammars (HAGs). It operates on abstract syntax and is based on tree modules generated by Ast. The features of Ag include:

a fully known tree structure;

any target language type for attributes,

tree-valued attributes,

an extension mechanism,

attribute computations written in a functional style,

a modular architecture,

checking for completeness of the attribute computations as well as for unused attributes, and

direct coding of the evaluators using recursive procedures.

Puma is a transformation tool based on pattern matching.
The Cocktail toolbox is implemented in Modula-2. It was developed and can be used with the freely available MOCKA compiler. A extensive user's guide is available in PostScript format. The Cocktail tools can also understand lex and yacc syntax with the help of a couple of preprocessors supplied in the distribution.
[http://www.first.gmd.de/cocktail/]
[http://sunsite.doc.ic.ac.uk/computing/compilers/tools/cocktail/]
[ftp://i44ftp.info.uni-karlsruhe.de/pub/cocktail/]

Cocktail95

A modification of the original Cocktail compiler toolkit such that the tools will generate Ada-83 and -95 code.
[http://www.informatik.uni-stuttgart.de/ifi/ps/cocktail/]
CoCoA: Computations in Commutative Algebra is a computer algebra system designed for maximum ease of use and flexibility for mathematicians who aren't computer gurus. CoCoA can perform simple and sophisticated operations on multivariate polynomial rings and on various data connected with them such as ideals, modules, matrices and rational functions. In additional to performing such basic operations as sums, products, powers and derivatives of polynomials, rational functions and ideals, several more advanced operations are available including:

Groebner bases, syzygies, minimal free resolutions, intersection and division, and inclusion and equality tests for ideals and modules;

elimination of indeterminates;

homogenization of ideals;

Poincare series and Hilbert functions; and

factorization of univariate polynomials over the integers.

The CoCoA system consists of a kernel written in C and a library of programs written in a Pascal-like programming language called CoCoAL that lets users customize and extend the system. It is portable to different machines via an interface to a platform-independent Low Level Protocol (LLP) layer. The platform independent part consists of two modules. ENGINE is the main motor, an interpreter for CoCoAL which allows it to exchange LLP inputs and outputs with the interface. Computational requests are forwarded from ENGINE to MATH, which contains all of the mathematical algorithms to manipulate coefficients, polynomials, ideals and modules. It accepts requests, converts data from LLP to an internal format, and then performs the mathematical task.
Binary distributions of CoCoA are available for several platforms including Linux Intel. Documentation includes a user's manual and a tutorial as well as several technical reports concerning the development of the system.
[http://cocoa.dima.unige.it/]
COCOM: A set of tools for the creation of compilers, cross-compilers, interpreters, and other language processors. One component of COCOM is Ammunition, a set of several reusable packages including:

allocate, for allocating and freeing memory with automatic fixing of some errors;

vlobject, for working with variable length objects;

objstack, for working with stacks of objects;

hashtab, for working with hash tables;

position, for working with source code positions;

errors, for handling compiler error messages;

commline, for working with the command line;

ticker, for working simultaneously with several timers;

bits, for working with bit strings;

arithm, for implementing host machine independent arbitrary precision integer arithmetic; and

IEEE, for implementing host machine independent IEEE floating point arithmetic.

Other COCOM components include:

SPRUT, which translates code in compiler internal representation description (IRD) format into Standard Procedural Interface (SPI) format;

NONA, a translator of machine description into code for solving code selection and other back-end tasks;

MSTA, a syntax description translator that can emulate YACC and has seceral additional features;

OKA, a pipeline hazards description translator; and

SHILKA, a keywords description translator designed for fast recognition of keywords and standard identifiers in compilers.

A source code distribution of all components is available. Everything is written in ANSI C with documentation is the usual formats.
[http://www.geocities.com/SiliconValley/Lab/4557/]
Cocoon: A Java publishing framework servlet that uses DOM, XML and XSL to provide Web content. This project aims to change the way Web information is created, rendered and delivered. The goal is to separate document content, style and logic such that they can be independently designed, created and managed to reduce management overhead and increase reuse. In Cocoon content is written using XML, style on XSL stylesheets, and logic on a yet to be designed format called XLogic logicsheets. Cocoon creates Web content by processing these layers to create, for example, HTML output. A source code distribution is available.
[http://java.apache.org/cocoon/]
Coco/R: A tool that combines the functionality of lex and yacc to form a compiler generator that generates recursive descent parsers, their associated scanners, and a driver program from attributed grammars (in EBNF syntax) which conform to LL(1) parsing restrictions. To get a running compiler, the user has to add modules for symbol table handling, optimization, and code generation. There are versions of Coco/R available for Oberon, Modula-2, Pascal, C/C++, and Java.
[http://cs.ru.ac.za/homes/cspt/cocor.htm]
Coda: An advanced networked file system descended from the Andrew File System (AFS). It contains several features needed by networked filesystems and usually not available elsewhere including:

high performance via client-side persistent caching;

server replication;

a security model for authentication, encryption and access control;

disconnected operation for laptops;

continued operation during partial network failures in the server network;

network bandwidth change adaptation;

good scalability; and

well-defined semantics of sharing even during network failures.

A pre-alpha version (5/97) is available for Linux platforms. It is available in the form of either an RPM package or a tarred and compressed file. There is a large collection of documents available in PostScript format which document the system and its various parts.
[http://www.coda.cs.cmu.edu/]
CODA: Conservation Options and Decisions Analysis is a software package for nature conservation planning. It assists in the design of networks of nature reserves or protected areas and has been used both for major planning studies and as a teaching resource. The CODA framework for regional conservation planning begins with the definition of four layers of data, i.e. the parcels of land in question, the components of each region's biodiversity, classes of suitability for conservation within each region, and the costs associated with each area. The next step involves setting conservation objectives, i.e. defining explicit targets for the number or extent of each conservation feature to be sampled by the network of protected areas. In the next step an initial network is constructed using an iterative algorithm that attempts to identify the smallest or least costly set of selection units that meet the objectives. The final step involves modifying the initial network to meet other objectives.
A source code distribution of CODA is available. It has been successfully compiled on a Sun machine using GCC 2.7.2. Compilation also requires the Xbase database package, the wxWindows GUI library, and the Motif widget set.
[http://www.ozemail.com.au/~mbedward/coda/coda.html]
CodeLib: A collection of codes developed by Prof. P. Deuflhard and his colleagues at Konrad-Zuse-Zentrum fuer Informationstechnik Berlin (ZIB). These mainly deal with solutions of single or systems of differential and/or algebraic equations. The programs in CodeLib include: ALCON1, ALCON2, ALCON-S, BVPLSQ, BVPSOG, BVPSOL, DIFEX1, DIFEX2, DIFEXM, EULEX, EULSIM, GBIT, GIANT, KEPLEX, LARKIN, LIMEX, LIMEXS, METAN, MEXX, MULCON, NLEQ1, NLEQ2, NLSCON, PERHOM, PERIOD, and SYMCON.
[ftp://elib.zib.de/pub/elib/codelib/]
CODE: The Computationally-Oriented Display Environment is a visual parallel programming system which allows users to compose sequential programs into a parallel program. The parallel program is a directed graph where data flows on arcs connecting nodes that represent sequential programs. The sequential programs can be written in any language and CODE will produce parallel programs for a variety of architectures. It is primarily designed to support coarse-grained parallelism with the chunks usually written in C although they can be written in any language that can be linked into C. CODE can produce programs for three types of architectures: (1) a purely sequential program that simulates parallelism; (2) a shared-memory multiprocessor machine such as the Cray J90 or Sun SparcCenter that uses POSIX threads; and (3) a distributed memory cluster that uses either PVM or MPI. CODE should run on any UNIX system.
[http://www.cs.utexas.edu/users/code/]
Code Crusader: A C/C++ code development environment written using the JX package. The features include: the graphical display of a C++ inheritance hierarchy with searching for classes by name, searching for classes that implement a particular function, lists of functions implemented by a particular class, instant access to source and header files, and output in PostScript format; integrated support for make which parses error messages from gcc and opens the file to the line where the error occurred as well as integrated support for executing or debugging the result; a text searching window; file backup; memory of preferred window geometries for each file type; a multiple document interface which prevents mistakes caused by editing the same file in different windows; project support which remembers which files were open in where in each you were working as well as the commands used; configuration performed via dialog windows rather than config files; on-line help; and more.
A source code distribution is available as are binaries for several types of platforms including Linux Intel. Compilation requires the JX library.
[http://www.cco.caltech.edu/ jafl/jcc/]
codegroup: A program that encodes and decodes arbitrary binary data in five-letter code groups.
[http://www.fourmilab.ch/codegroup/]
CODE++: Classes for Ordinary Differential Equations is a collection of C++ class libraries for ordinary differential equations and related problems. It was originally developed to unify a family of adaptive extrapolation codes and some multiple shooting method programs based on these integrators, and it has also been used for the fast prototyping of new numerical algorithms, with one example being the COST package.
The classes in CODE++ are divided into several smaller libraries including:

matlib, a library containing basic linear algebra classes and utilities collected into utility, basic linear algebra, and basic container classes;

odelib, a library containing classes for the description of ODEs and their solution via adaptive integration methods with subclasses here contain ODE descriptors, adaptive order and stepsize control integration methods based on local error estimation and some error model, extrapolation methods to generate solutions of higher order, and methods for accessing information about the solution of an ODE during the integration process;

nonlin, a library dealing with nonlinear problems and solvers, currently differentiable unconstrained nonlinear problems and Newton-like methods for their solution;

sparse, a library containing sparse matrix classes and interfaces to sparse solvers, with the latter being Harwell's sparse matrix solver;

shoot, a library containing multiple shooting method algorithms;

latool, a library containing an interface to the linear algebra package LAPACK; and

special, a library containing special functions e.g. Bessel functions.

A source code distribution of CODE++ is available. It is written in C++ and has been compiled on several different compilers. It has been compiled with gcc 2.5.8 but as of this writing (6/97) has not been adapted to the new template scheme of 2.6.*. The classes are documented in both HTML and PostScript formats, and a user's guide is also included in HTML format.
[ftp://ftp.zib.de/pub/Packages/code++/]
Cohesion: An advanced semantic net modeling tool for use in software development. The features include:

a client-server architecture;

creating a custom modeling language or using one of the available predefined languages;

model creation using the advanced modeller (with the capability of changing notations on the fly);

a concurrent versioning system that allows a single master copy to be accessed by multiple users;

user management capabilities that enable secure remote system access control;

instant messaging and email capabilities;

locally and server stored address books;

a secure user/password system; and

secure encryption between clients and servers.

[http://cohesion.it.swin.edu.au/]
Coin: An OpenGL-based, retained mode 3-D graphics rendering library implemented in C++ and with an API based on that of Open Inventor. The goal of the project to create an API completely compatible with that of Open Inventor. The features include:

high-level 3-D development features, e.g. importing, rendering and interacting with a 3-D object in just a few lines of code via a scene-graph oriented class library;

use of OpenGL for accelerated rendering;

a C++ interface;

cross-platform capabilities; and

use of the same API as Open Inventor.

A source code distribution is available under the QPL.
[http://www.sim.no/coin.html]
COIN: The Common Optimization INterface for Operations Research is an initiative to spur the development of open source software for the operations research community. The goal is to build an open source community for optimization software for the purposes of speeding deployment of models, algorithms and research. A pool of source code is being seeded by establishing a repository of several interrelated, solver-independent, open source projects:

BCP, a parallel branch-cut-price framework;

CGL, a cut generation library;

FAA, a set of fast approximate algorithms, e.g. the volume algorithm;

DFO, a package for the optimization of general nonlinear problems of relatively small scale; and

OSI, an open solver interface layer.

[http://oss.software.ibm.com/developerworks/opensource/coin/]
COLD: A network sniffer and protocol analyzer for troubleshooting and educational purposes. COLD can obtain data from several different network devices including PPP links, Ethernet cards, Token Ring cards, loopback devices, and ISDN connections. The supported protocols include 802.1 BPDU, 802.2 LLC, 802.3 MAC, 802.5 Token Ring, SNAP, NETBIOS and IPX, ARP, IP, ICMP, TCP and UDP. A source code distribution is available, and this is also included in the Trinux distribution.
[http://www.panservice.it/cold/]
ColdStore: A gigabyte-scale persistent object store which provides:

extent-based allocation for maximum spatial locality of reference and a minimal working set;

interning of ELF symbols so a class implementation can change without having to rebuild the store;

a rich set of container and basic classes optimized with respect to the QVMM allocator; and

a language called Chaos designed to provide low-level access to objects as well as regression testing of the store and its application classes.

ColdStore is intended for those looking for a way to store heterogeneous data, access it, and process it quickly.
The capabilities and functionality of ColdStore include:

constructing persistent objects within a program who pointers and references still work if the program is stopped and started;

changing library code implementing objects without having to reconstruct the store;

allocating memory in extents or neighborhoods such that allocations are clustered onto a small set of hardware pages;

optionally using an entire library of classes designed or adapted to work well with extent-based allocation, e.g. array/lists, tuples, dynamic strings, dictionaries, BTrees, symbols, namespaces, big integers, arbitrary precision floats, regular expressions, etc.; and

leaving out the unneeded parts of the system.

A source code distribution is available under the GPL.
[http://coldstore.linuxbox.com/]
ColEm: A portable emulator for the ColecoVision video game system. This is written in C with source code and binaries available for several platforms. The UNIX version is available as source code.
[http://www.komkon.org/fms/ColEm/]
Collaborative Virtual Workspace: A prototype collaborative computing environment designed to support temporally and geographically dispersed work teams. CVW provides a persistent virtual space within which applications, documents and people are directly accessible in rooms, floors and buildings. The functionality includes:

rooms and floors providing context for collaborations within and a graphical map display of the floor plan to aid navigation;

several types of supported objects with which people can interact including folders, room recorders (i.e. note takers), notes, documents and whiteboards;

room access control;

extensive textual communications capabilities including direct communication from a person to a person or a group, private communication with someone in the same or another room, non-verbal expressions such as nodding, pasting text selections from another application to people in a room, and sending a URL as a hot link to people in a room;

multipoint audio and video conferencing that is self-configuring on a per room basis;

color-coded room scrollback;

room recording of all public text communication;

the creation and sharing of data objects including notes, documents, URLs, folders and whiteboards;

a persistent shared whiteboard that enables multiple people to view and annotate images; and

searching of all document types, rooms and people.

[http://cvw.mitre.org/]
COLMOD: An extension of the COLNEW package for the solution of singularly perturbed boundary value problems (BVPs) using an automatic continuation strategy. This differs from COLNEW in that it uses a different mesh selection algorithm more amenable for use with the boundary layers found in such problems. See Cash et al. (1995).
[http://www.ma.ic.ac.uk/~jcash/BVP_software/readme.html]
COLNEW: A package for the solution of boundary value problems (BVPs) for ordinary differential equations (ODEs). COLNEW is a modified version of the COLSYS package wherein the B-splines are replaced with a collocation method. A Runge-Kutta-monomial solutin method is used. The program is written in Fortran and is documented in the source code. This program is extended in COLMOD. See Ascher et al. (1981) and Bader and Ascher (1987).
[http://www.ma.ic.ac.uk/~jcash/BVP_software/readme.html]
COLRED: A package for the column reduction of polynomial matrices. This is TOMS algorithm 767 and is documented in Guerts and Praagman (1997).
[http://www.acm.org/calgo/contents/]
Colt: A set of open source libraries for high performance scientific and technical computing in Java. Colt contains efficient and usable data structures and algorithms for on- and off-line data analysis, linear algebra, multi-dimensional arrays, statistics, histogramming, Monte Carlo simulation and parallel and concurrent programming. The component libraries include:

Colt, provides fundamental general purpose data structures optimized for numerical data, e.g. resizable arrays, dense and sparse matrices, linear algebra, associative containers and buffer management;

Jet, contains mathematical and statistical tools for data analysis, histogramming functionality, random number generators and statistical distributions;

JAL, a partial port of STL to Java;

RngPack, contains random number generators;

CoreJava, contains C-like print formatting;

Concurrent, contains standardized, efficient utility classes commonly used in parallel and concurrent programming; and

VNI, contains mathematical functions and complex numbers.

[http://tilde-hoschek.home.cern.ch/~hoschek/colt/index.htm]
COMEDI: The COntrol and MEasurement Device Interface is a collection of hardware drivers, a common kernel interface, and a support library for data acquisition hardware. COMEDI supports single A/D conversions, timed A/D conversions on a single channel, timed A/D conversions on multiple channels, single D/A conversions, and digital I/O. It is implemented as a kernel module that is accessed via character devices, and the library is used to facilitate communication with the driver. The driver currently (7/98) supports several hardware devices including:

Data Translation DT2811, DT2814 and DT2817;

Data Translation DT2821 series;

National Instruments AT-MIO E series;

Generic 8255 chip support;

PCL-711 PC LabCard; and

standard parallel printer port.

A source code distribution is available.
[http://www.llp.fu-berlin.de/pool/software/comedi/]
[http://stm.lbl.gov/comedi/]
Common C++: A C++ framework offering portable support for threading, sockets, file access, daemons, persistence and system services. The goal of this official GNU package is to promote a very low overhead abstract C++ interface to common system services. For example, it supports portable classes for threading and socket support for both UNIX (i.e. POSIX systems with pthreads support) and the Win32 API.
The component libraries of Common C++ are:

libccxx, for portable threading and realtime sockets;

libccio, lightweight file access classes;

libccstd, an object class persistence engine, a math library, C++ HTML document processing, and miscellaneous classes; and

libccio, APE stream/serial device classes.

[http://cplusplus.sourceforge.net/]
Common Lisp: A dialect of the Lisp language whose origins can be traced to a DARPA sponsored meeting held in 1981 when a group of Lisp users met to attempt to unify what were becoming too many divergent versions of Lisp. Common Lisp was designed as a description of a family of languages with the semantics deliberately underspecified in places to prevent an overly tight specification from hindering research and use. A technical working group called X3J13 was formed in 1986 to produce a draft for a Common Lisp standard. Their goals differed from those of the earlier group for various reasons and included stricter standardization for portability, an object-oriented programming system, a condition system, iteration facilities, and a way to handle large character sets.
The goals for which Common Lisp was designed by the 1986 group include: commonality, i.e. to serve as a common dialect to which each implementation can make necessary extensions; portability in that it is easy to write programs that depend as little as possible on machine-specific characteristics; consistency, i.e. an explicit requirement for the interpreter and the compiler to impose identical semantics on correct programs as much as is possible; expressiveness, i.e. the use of the most useful and understandable constructs from several previous Lisp implementations; compatibility, i.e. striving to be compatible with various previous implementations unless there is a good reason not to; efficiency, i.e. a number of features designed to facilitate the production of high quality compiled code in implementations which include and optimizing compiler; power, i.e. the provision of quality system building tools; and stability, i.e. the specification will change slowly.
Packages which implement Lisp interpreters and/or compilers or Commmon Lisp extensions include:

AKCL,

Allegro Common Lisp,

CLiCC,

CLISP,

CMUCL,

ECL,

EusLisp,

GCL,

iLisp,

KCL, and

Screamer.

See the CMU Common Lisp Repository. See Allen (1978), Cameron and Dixon (1992), Gabriel (1985), Graham (1994), Graham (1996), Harrison (1990), Hasemer and Domingue (1989), Hennessey (1989), Keene (1989), Koschmann (1990), Lawless and Miller (1991), Miller and Benson (1990), Norvig (1992), Paepcke (1993), Queinnec (1996), Sangal (1991), Shapiro (1992), Steele (1990), Touretzky (1990), and Winston and Horn (1989).
Communication System Toolbox: A Matlab toolbox containing a collection of programs (m-files) for performing various tasks on the digital coding of waveforms and on digital data transmission systems. This was developed for an interactive laboratory course at a university. The nearly 100 m-files in this package are used for the performance of seven laboratory simulations. The topics covered are probability theory, random processes, quantization, binary signalling formats, detection, digital modulation, and digital communication.
The Toolbox can be used with Matlab or with the freely available Octave which can run most Matlab m-files. It is documented in a 106 page lab manual in PostScript format created for the course.
[ftp://ftp.mathworks.com/pub/contrib/v4/misc/comm_tbx/]
CompactNET: A multiprocessing system for applied computing applications in the communications and automation industries. CompactNET provides the functionality of a network in a compact, modular configuration suitable for applications with limited space and maintenance resources. A CompactNET system integrates CompactNET hardware, standard OS support, and standard network software protocols into a scalable multiprocessing application. A typical configuration consists of a single System Master CPU board and up to 32 Peripheral Master CPUs, with multiple CPU boards capable of operating in a single backplane like a network in a box. The CPU boards communicate using standard network protocols over the CompactPCI backplane, with each board capable of having one of several different OS choices including Linux. The Linux drivers for the CompactNET hardware are available as Open Source.
[http://www.compactnet.com/]
compare: A program that compares two pieces of text for similarities. This has been used to automatically find literary allusions in various pieces of text. Originally developed for the purposes of rejecting very similar but not identical entries on a mailing list, compare has found wider application in searches for similarity in literature. The models implemented to find a measure of similarity include:

a shared word model wherein long strings of identical letters indicate similarity unless they contain extremely common or ``noise'' words, e.g. the, a, of, etc.;

a shared word model wherein identical words indicate similarity unless they are extremely common words;

a shared collocation model wherein runs of identical words indicate similarity;

a shared word stem model wherein the roots or stems of words are compared rather than the verbatim words themselves; and

a shared vocabulary model in which values are assigned to words based on their relative frequency of use.

Two versions of compare are available. The first is written in C and implements the literal models in which identical letters, words and word strings are used to calculate similarity. The second version is written in Perl and implements the shared vocabulary model.
[http://www.english.upenn.edu/~jlynch/Computing/compare.html]
compiler construction tools: Such tools can be divided into several categories including:

compiler construction kits

Cocktail, a set of generators for most phases of a compiler;

Eli, programs for almost all of the tasks required to create a language;

Gentle, an integrated system for compiler construction with all the necessary tools; and

PCCTS, a tool for the construction of language recognizers and translators.

a

lexer and parser generators

ALE, a logic programming and grammar parsing and generation system;

BtYacc, a modified yacc supporting automatic backtracking and semantic disambiguation for parsing ambiguous grammars;

Bison, the GNU version of yacc;

byacc, the Berkeley version of the AT&T yacc;

Coco/R, a tool combining the functionality of lex and yacc;

Depot4, a system for implementing language processors that used an extension of EBNF called Ml4;

EAG, a compiler that uses the EAG formalism;

Elex, a multi-language scanner generator that generates a scanner from a specification oriented around regular expressions;

Flex, the GNU version of lex;

LLgen, a tool for generating an efficient recursive descent parser from an ELL(1) grammar;

NewYacc, an extensino to yacc;

PRECCX, an infinite-lookahead compiler compiler for context dependent grammars;

RDP, a parser generator that compiles attributed LL(1) grammars decorated with C semantic actions into recursive descent compilers;

SYNTAX, a system combining the capabilities of lex and yacc with extract features including better error processing;

Zlex, a lex-compatible scanner generator with additional features; and

Zyacc, a general purpose parser generator that converts descriptions in LALR(1) into C programs to parse that grammar.

attribute grammar systems

Elegant, a programming language based on attribute grammars;

FNC-2, an AG system based on strongly non-circular AGs that performs extensive space optimizations;

Ox, an attribute grammar compiling system; and

RIE, a package based on one-pass AGs called ECLR-attributed grammars.

transformation tools

RIGAL, a compiler construction language whose data structures are atoms, lists, and labeled trees and whose control structures are based on advanced pattern matching;

TXL, a programming language and rapid prototyping system designed to support transformational programming;
compression/archiving: A useful site for such things is:

Compression Pointers
http://www.internz.com/compression-pointers.html

Compression/uncompression software in this collection includes:

base64, for encoding and decoding files in Base64 format;

bzip, a data compression package;

GSM, a lossy speech compression algorithm;

gzip, the GNU compression package;

HPACK, a compression utility package;

Info-ZIP, free versions of the Zip and UnZip utilities used under DOS;

JBIG-KIT, compression for bi-level, high-resolution images such as scanned documents;

JPEG, an image compression standard for which several packages are available;

LZO, a data compression library;

lzop, a compression utility;

metamail, can handle base64 compressed files;

miniLZO, a lightweight version of LZO;

MPEG, a standard for digital video and audio compressionn for which several packages are available;

PNG, a portable graphics format with compression;

szip, a portable, lossless compression program;

UPX, a portable high-performance packer for several executable formats; and

zlib, a lossless data compression library.

Archiving software includes:

afio, produces archives in cpio format;

binutils, which contains an archiving program called ar;

CIF, an archiving standard for crystallographic data;

cpio, a program to manage file archives;

FITS, a format for archiving astronomical data;

macutils, a set of utilities for handling Macintosh format archive files;

makeself, a shell script that generates a self-extractable tar.gz archive from a directory;

star, a tar-like archiver.
Computational Fluid Dynamics: An extensive list of freely and commercially available computer programs pertaining to the broad sweep of computational fluid dynamics.
[http://www.math.psu.edu/dna/CFD_codes.html]
[http://www.fges.demon.co.uk/cfd/CFD_codes.html]
Entries related to CFD include:

BURGER, a collection of codes for solving the Burger's equation;

CAVITY, a collection of codes for solving the Navier-Stokes equation in a 2-D cavity;

ddcon2d, solves the 2-D Navier-Stokes equations for Boussinesq convection using the Fourier Galerkin/collocation method;

FEAT, a finite element package containing a program called FEATFLOW for solving the incompressible Navier-Stokes equations;

FLUX, a code for comparing discretization schemes for the 1-D linear advection and Burger's equations;

HAMR, for simulating the Euler equations of gas dynamics in an adaptive mesh refinement framework;

NaSt2D, a 2-D solver for the incompressible, transient Navier-Stokes equations;

NSC2KE, a finite volume Galerkin program for computing 2-D flows on unstructured meshes;

NSUVP, a code for solving a UVP formulation of the Navier-Stokes using finite elements;

VarDen, a library of classes for simulating the variable density incompressible Navier-Stokes equations on a single rectangular grid;
computational geometry: Related software includes:

Alpha Shapes, for reconstructing surfaces and volumes from given point clouds;

DT_NURBS, a spline geometry subroutine library;

Euslisp, a robotics testbed;

Geomview, an interactive viewer for three and higher dimension geometry;

IRIT, a solid modeling package consisting of a main module with hundreds of functions and several ancillary programs;

LEDA, a library for graph theoretic and geometric algorithm implementation; and

SOLID, a library for collision detection of 3-D objects.

See also the mesh generation section.
computational number theory: Related entries include:

apfloat, a high performance arbitrary precision arithmetic package;

ARIBAS, an interactive interpreter for big integer arithmetic and multiple-precision floating point arithmatic;

bc, a calculator language supporting exact calculations with arbitrary precision numbers;

CALC, a calculator program for doing arbitrary precision integer arithmetic;

CLN, a class library for numbers;

FreeLIP, a library of functions for performing arithmetic on arbitrary length signed integers;

KANT, a computer algebra system for sophisticated computations in algebraic number fields;

LiDIA, a library for computational number theory;

NTL, a high performance number theory library;

PARI-GP, a package for performing formal computations on recursive types at high speed;

SIMATH, a computer algebra system for number theoretic purposes; and

ZEN, a toolbox for fast computations in finite extensions of finite rings.
computer algebra: Related sites include:

Computer Algebra Information Network
[http://www.riaca.win.tue.nl/CAN/]

Several packages are available for performing computer algebra computations on Linux platforms. These include:

ALP, a C++ class for scientific computing with an emphasis on linear and polynomial algebra;

APU,

Calc,

Computer Algebra Kit,

FELIX,

FORM,

GAP,

GiNaC,

JACAL,

KANT,

Macaulay2,

MAS,xi

Mathomatic,

MAXIMA,

Mockmma,

MuPAD,

NTL,

PARI-GP,

Risa,

SACLIB,

SAML,

SIMATH,

Singular,

Symmetrica, and

Yacas.
Computer Algebra Kit: A collection of programs or objects for performing computer algebra tasks. The kit provides objects for multi-precision integer arithmetic, computing with polynomials, computing with matrices of integers, and more. There versions of this for NextStep, Stepstone and GNU Objective C. Demo version for the latter are available for Sun and Linux platforms.
[http://users.pandora.be/stes/]
computer vision: Related packages include:

CppIma, an image processing library;

CVIPtools, a package for the exploration of computer vision and image processing;

ImageLib, a C++ library for image processing;

ImgStar, a collection of over 70 command-line image processing tools;

IUE, a comprehensive environment for performing advanced research in image understanding;

Radiance, a synthetic imaging system for lighting design and rendering;

SIZE, programs for describing and comparing shapes of topological spaces, e.g. images;

SLAM, a package for working with appearance learning and matching problems in computational vision;

SUSAN, a set of programs implementing algorithms for image noise filtering and edge and corner finding;

TargetJr, an integrated image understanding environment for computer vision research;

TINA, a set of libraries for simplifying vision algorithm development and evaluation;

VISTA, a computers graphics and vision development environment;

[http://www.cs.cmu.edu/~cil/v-source.html]
Concorde: The Combinatorial Optimization and Networked Combinatorial Optimization Research and Development Environment is a package for exploring and solving the traveling salesman problem (TSP) and some other related network optimization problems. The Concorde callable library contains over 700 functions permitting users to create specialized codes for TSP-like problems, with all functions thread-safe for use in shared-memory parallel environments. The main TSP solver includes code for running over networks of workstations.
The features of Concorde include:

a broad implementation of the Dantzig, Fulkerson and Johnson cutting plane method including exact subtour and blossom separation, heuristics for combs, clique trees, double deckers, and stars, and a separation routine for local cuts;

branch-and-bound using both edge branching and branching on subtour inequalities;

support for the CPLEX linear programming solver;

a portable Held-Karp based solver for small TSP instances (up to 100 cities);

a fast combinatorial based solver for tiny TSP instances (up to 25 cities);

a linear programming based solver for small instances of the m-TSP (up to 100 cities);

an efficient implementation of the Martin, Otto and Feldman chained Lin-Kernighan algorithm suitable for up to 1 million cities;

kd-tree based algorithms for 2-opt, 2.5-opt, 3-opt, nearest neighbor, greedy, Boruvka and farthest addition tours; and

algorithms for computing global minimum cuts, minimum s-t cuts, Gomory-Hu trees, and minimum spanning trees.

[http://www.keck.caam.rice.edu/concorde.html]
Condor: A high throughput computing environment that can manage very large collections of distributively owned workstations. It is an environment based on a novel layered architecture which enables it to provide a powerful and flexible suite of resource management services to sequential and parallel applications. Condor uses unique remote system call capabilities to preserve a large measure of the originating machine's environment on the execution machine, even if the machines do not share a common file system or user ID scheme.
The features of Condor include:

checkpointing and migration in which a program running on a computer can, when the situation demands, be either stopped, saved and restarted on another machine or on the same machine, with regular checkpointing also available for protecting accumulated computations;

preservation of the local execution environment via RPCs so users don't have to worry about making data files available on remote workstations or obtaining accounts on them;

no special programming is needed to use Condor in that everything other than the Condor-specific calls are transparent to the user;

complete and automatic control of use priority by the owners of each computer in a Condor cluster; and

a ClassAd mechanism which provides a flexible, semantic-free and expressive framework for matchmaking between resource requests and resource offers.

Condor can be obtained in source code form or in binary format for several platforms, e.g. Linux Intel, SGI Irix, HP HPUX, Sun Solaris, and DEC ALpha. The documentation is included in each distribution and is also available separately. A Condor View Library, written in Tcl/Tk, is available as an ancillary package. Although not included in current (3/97) releases, a Condor Application Resource Management Interface (CARMI) will be integrated into future releases. It is a framework for interfacing resource management systems with parallel processing systems, with the current version interfacing with PVM. There is a special set of pages for the Condor Linux port.
[http://www.cs.wisc.edu/condor/]
confcntlr: An MBone conference controlling tool intended to allow easier access to, control of, and coordination of a videoconference over the Web. It is run on all machines participating in the videoconference and is used to control the audio and video portions. It was developed to be used with vic and vat. The confcntlr GUI allows a user to initiate actions and set the controls for both the video and audio. A source code distribution is available. It is written in C and Tcl/Tk and can be compiled on most UNIX platforms.
[http://www-itg.lbl.gov/mbone/confcntlr/]
conferencing/collaboration systems: Package for facilitating group discussions on the Web. This category includes BBS and forum software, groupware, virtual community software, message boards, and software for collaborative work groups. The available packages include:

BBBS

BBMATIC

Ceilidh

Collaborative Virtual Workspace

COW

Diary

Discus

Egret

ERIDU, a web-based groupware application similar to Microsoft Outlook in functionality;

eThreads

FruitBBS

Futplex

HyperNews

JAMM

Keystone

meep!Board

NetForum

Phorum

RPGBoard

Ruboard

Sporum

VBS

ViNE

VMatik

W-Agora

w3news

WWWBoard

Systems for creating gateways between email and the Web include:

Hypermail

LWGate

MHonArc
conflib: A C language library for handling simple or complex ASCII configuration files. The features of conflib include:

extensive portability via autoconf;

support for building as a shared library via libtool;

allows the inclusion of other configuration files;

a built-in macro language;

interpretation of values in configuration files; and

support for a wide range of data types.

A source code distribution is available.
[http://194.245.36.15/uwe/conflib.html]
Confman: A tool for initiating and administering online conferences using the Mbone tools. Confman does not itself handle multimedia data but rather helps the user to plan, set up, and control a conference. It allows you to choose your partners, the starting time, and the tools you wish to use. It can be used in both unicast and multicast mode and also supports closed conferences. Binary distributions are available for several platforms including Linux Intel. Documentation is mostly in German with some in English.
[http://www.rvs.uni-hannover.de/products/confman/index_en.html]
CONFPACK: A package of Fortran subroutines to perform conformal mapping using Symm's integral equation. In addition to the confpack file there are also files called pargen and confdrivers which are, respectively, a preprocessor and example driver programs for CONFPACK.
The routines in the CONFPACK distribution include:

JAPHYC, which solves Symm's integral equation to estimate to Jacobi coefficients for the density associated with the map;

GQPHYC, which sets up the global composite Gaussian quadrature rule for computing the map;

DMPHYC, which computes the vector of approximate image points in the canonical domain given a vector of arbitrary points in the physical domain;

CNDPLOT, which examines the condition of the mapping problem and outputs data for plotting graphs of the boundary correspondence function and its derivative;

JACANP, which estimates the Jacobi coefficients for the density associated with the map;

GQCANP, which sets up the global composite Gaussian quadrature rule for computing the map;

DMCANP, which computes the vector of approximate image points in the physical domain given a vector of arbitrary points in the canonical domain;

BMPHYC, which computes the corresponding approximate image point on the unit disc given a point on the boundary of the physical domain;

BMCANP, which computes the corresponding approximate image point on the boundary of the physical domain given a point on the unit circle; and

LEVCUR, which generates level curve plotting data.

A source code distribution of CONFPACK is available. It is written in Fortran 77 and there seems to be no documentation available other than scattered comment statements contained within the source code files. There is supposed to be a user's guide to the package but the given FTP address no longer accepts anonymous FTP.
[http://www.netlib.org/conformal/index.html]
Conglomerate: A project to create a complete structured information authoring, management, archiving, revision control and transformation system. It will combine XML semantics, graphical editing, a centralized storage model, and a flexible transformation language to create an environment for producing high-quality structured output. A single source document can be processed into several types of output media. This is currently (5/00) very much in the alpha stage of development.
[http://www.conglomerate.org/]
CONHYP: A Fortran 77 program for numerically evaluating the confluent hypergeometric function for complex arguments with large magnitudes using a direct summation of Kummer's series. The final result is obtained using extended precision subroutines with large arrays to accumulate both the numerator and denominator, with the result usually accurate to 13 significant figures. This is TOMS algorithm 707 and is documented in Nardin et al. (1992).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
CONICAL: A C++ class library for building simulations commmon in computational neuroscience. CONICAL currently focuses on compartmental modeling in which a model neuron is built out of compartments, i.e. open-ended cylinders which can approximate almost any geometry. All compartments have passive electrical properties as well as more interesting properties which require the use of active ion channels whose conductance varies as a function of the time or membrane voltage. Connections between neurons can be implemented in several ways. For example, a passive current is used for a gap junction. Both alpha-function and Markov-model synapse models are available.
The classes in CONICAL include:

AlphaSyn, an alpha-function synapse;

Channel, a variable conductance current;

ChanAB, an alpha/beta Hodgkin-Huxley channel;

ChanHH, a Hodgkin-Huxley ion channel;

ChanStd, a standard Hodgkin-Huxley ion channel;

Compartment, an isopotential volume;

Current, a current source to a VSink;

Cylinder, an isopotential, cylindrical compartment;

Delay, a link with a time delay;

Injector, an ideal current source;

Link, a VSource to VSink connection;

Markov, a Markov kinetic model;

MarkovSyn, a Markov synapse;

Spiker, an integrate-and-fire compartment;

Stepmaster, which unites a set of Steppers;

Steppers, which provides a step(dt) method;

StepStream, a columnar output generator;

Synapse, a neurotransmitter gated channel;

VSink, a voltage sink; and

VSource, a voltage source.

A source code distribution of CONICAL is available. It is written in C++ and known to compile on Linux platforms using gcc 2.7.0 or later. A user's guide is included in the basic distribution.
[http://www.strout.net/conical/]
CONMAX: A set of Fortran programs for general nonlinearly constrained function minimization. The package also contains routines for Muller's method for real root finding, line search, free-variable linear programming, and least-distance quadratic programming. See ().
[http://www.netlib.org/opt/]
CONS: A replacement for make that is not compatible with it but has several capabilities not found in make. The features of CONS include:

a construction environment consisting of an object characterized by a set of key/value pairs and a set of methods;

automatic and complete dependency analysis;

automatic global build sequencing;

a hierarchy of build scripts in larger builds; and

relative, top-relative and absolute filenames.

A source code distribution of this collection of Perl scripts is available.
[http://members.home.net/garsh/cons/]
CONSENSUS: A program for determining consensus patterns in unaligned sequences based on a matrix representation of a consensus pattern. A source code distribution is available.
[ftp://beagle.colorado.edu/pub/Consensus/]
Console Tools: The Linux Console Tools are a set of programs that allow the setting up and customization of the console, i.e. the screen plus the keyboard. This is a continuation and enhancement of the kbd package. The console driver consists of two sub-drivers, i.e. the keyboard and screen drivers. The former sends characters to an application and the latter sends characters to the screen driver to be displayed. The keyboard driver consists of several levels:

the keyboard hardware which turns manual entries into scancodes;

a mechanism for turning scancodes into keycodes via a translation table; and

a mechanims for turning keycodes into characters via a keymap.

This driver can be in one of four modes which decides what type of data applications will get as input:

the scancode mode where the app gets scancodes for input, e.g. X11 which has its own keyboard driver;

the keycode mode where the app gets information on which keys get pressed and released;

the ASCII mode where the app effectively gets the characters defined by the keymap using an 8-encoding; and

the Unicode mode which allows the composition of UTF8 unicode characters by their decimal value.

The two available screen modes are:

the UTF mode in which bytes received from the app are interpreted as UTF8 sequences which are converted in the equivalent UCS2 codes and then looked up in the SFM to determine the glyphs needed to display each character;

a byte mode which uses an additional map to transform the byte characters sent by the app into UCS2 characters which are then processed as above.

The Console Driver has two slots for charsets, i.e. GO and G1, with each containing a reference to one of the four kernel ACMs. Three of these are predefined to provide the cp437, iso01 and vt100 graphics charsets and the fourth is user definable.
The programs in the Linux Console package are:

charset, sets an ACM for use in one of the GO/G1 character set slots;

chvt, makes /dev/tty N the foreground terminal which is created if it doesn't yet exist;

consolechars, which loads a font into the EGA/VGA character generator and optionally outputs the previous font;

deallocvt, deallocates kernel memory and data structures for all unused virtual terminals;

dumpkeys, dumps the current contents of the keyboard driver's translation tables;

fgconsole, prints the number of the active VT;

getkeycodes, prints the kernel scancode to keycode mapping table;

kbd_mode, reports or sets the keyboard mode;

loadkeys, loads the kernel keymap for the console;

psfaddtable, adds a Unicdoe character table to a console font;

psfgettable, extracts the embedded Unicode character table from a console font;

psfstriptable, removes the embedded Unicode character table from a console font;

resizecons, attempts to change the videomode of the console;

setkeycodes, loads kernel scancode to keycode mapping table entries;

setleds, sets the keyboard LEDs;

setmetamode, defines the keyboard meta key handling;

showfont, displays all characters in the current screen font;

showkey, examines the scan codes and key codes sent by the keyboard;

unicode_start, puts the console in Unicode mode;

unicode_stop, removes the console from Unicode mode; and

vt-is-UTF8, checks whether the current VT is in UTF8- or byte-mode.

A source code distribution of the utilities is available.
[http://www.multimania.com/ydirson/en/lct/]
CONTENT: A software package for the exploration of dynamical systems. The mathematical capabilities of CONTENT include continuation of generic and singular equilibria and periodic and homoclinic orbits, the detection of bifurcations, normal form computation, and branch switching, and the computation and processing of orbits. It has a user-friendly graphical interface, is extensible to additional numerical and dynamical system tasks, and is portable among several platforms.
CONTENT can handle ODEs, maps, and PDEs on the unit interval. The ODE capabilities include:

continuation of equilibria;

detection of branching, limit and Hopf points for equilibria;

continuation of codimension 1 bifurcations (fold and Hopf);

detection of codimension 2 equilibrium bifurcations (cusp, Bogdanov-Takens, generalized Hopf, zero-Hopf, and double Hopf);

conditional continuation of equilibrium and codimension 1 bifurcations;

branch switching between equilibrium bifurcations; and

simulation using Euler and Runge-Kutta methods.

It can also handle iteration maps and both continuation of steady states and detection of branching and limit points of PDEs on the unit interval.
CONTENT is available in binary format for SGI IRIX, Linux Intel, DEC Alpha, Sun SunOS, IBM AIX, and MS-DOS/Windows platforms. The documention is contained within a built-in help utility in the software.
[http://www.can.nl/Systems_and_Packages/Per_Purpose/ Special/DiffEqns/Content/GCbody.html]
[ftp://ftp.cwi.nl/pub/CONTENT/]
CONTIN: A package which implements a CONTINuation algorithm with an adaptive choice of a local coordinate system. It computes a sequence of solution points along a 1-D manifold of a system of nonlinear equations. It functions somewhat like an IVP ODE solver in that the user must specify an approximate initial solution, but it doesn't attempt to solve the problem by turning it into a system of ODEs. Rather, it selects a suitable variable as the current parameter at each time step and then determines the other variables as function of it. This lets the algorithm handle solutions curves which may bend and switch back in any direction.
CONTIN solves the algebraic equations explicitly at each step and each solution has to pass an acceptance test in an iterative solution process with tolerances supplied by the user. It is designed for systems with one degree of freedom, but can be used with more complicated systems by introducing suitable constraints to the nonlinear equation system which will serve to reduce the number of degrees of freedom. Options include the ability to search for solutions for which a given component has a specified value, and searching for a limit or turning point with respect to a given component.
A source code distribution of CONTIN is available. It is written in Fortran 77. Also available are several sample problems in the form of Fortran programs. It is documented in comments within the programs as well as in Rheinboldt and Burkardt (1983b), Rheinboldt and Burkardt (1983a), and Rheinboldt (1985). See the MANPAK entry for an updated and expanded version of this software. This is also known as PITCON.
[http://www.netlib.org/contin/index.html]
Converse: A portable parallel programming framework which can be used for developing portable parallel programs with support for messages, threads, shared memory, message handlers, and flexible schedulers. It can be used for quickly and easily building efficient runtime systems for parallel languages and also supports multilingual operability, i.e. modules written in different parallel languages can be linked together in a single application and carry out concurrent computations. This is achieved by a component-based (rather than layered) architecture in which only the components used incur a computational cost.
The components of Converse include:

a machine interface which includes messages, handlers, shared variables, locks, timers, etc.;

a simple, portable, and flexible thread abstraction;

a general purpose scheduler with customizable queueing strategy used for scheduling threads, message handlers, and any other user-defined entities;

a load balancer which handles the assignment of new objects of small tasks to processors;

a message manager to store and retrieve entities (usually messages) based on one or more indices or tags which can be used for implementing languages like PMV, Nxlib, or threaded versions of them; and

parameter marshalling, useful for directly programming using Converse which supports the marshalling of C function parameters for a well-defined class of types.

The languages currently (3/97) implemented include Charm and Charm++ (included in the distribution), a simple tag-based message passing library (SM) and its threaded version (tSM), PVM, MPI, a discrete event simulation language called Parallel Import, and an experimental language called Agents.
Converse runs on networks of UNIX workstations (currently Sun SunOS and Solaris, IBM RS/6000, and HP), the IBM SP1, the CM-5, the Paragon, the NCube, and the Cray T3D. Several Converse components are available only in binary form for the listed platforms, although support for more platforms is promised. I've already sent a request for Linux. The documentation is contained within several user's guides and reports, all of which are available in PostScript format. See Kale et al. (1996).
[http://charm.cs.uiuc.edu/]
conversion programs: Programs or program suites that convert one type of image, text, or data file into another type. Image conversion programs include:

fbm2fli, from 8 bit image to FLI/FLC animation;

hpcdtoppm, from Photo-CD to PBM;

ppm2fli, from PPM, PGM, PBM to FLI animations and vice-versa; and

XIcon, from XBM, OS/2, Windows, and Mac icons to XPM.
CONVERT: A Starlink Project package containing utilities for converting data files between Starlinks extensible N-dimensional Data Format (NDF) and a number of other common data formats.
The currently (6/97) conversion programs included in the package and their conversion tasks are: ASCII2NDF and NDF2ASCII, between a text file and an NDF; DST2NDF and NDF2DST, between a Figaro DST file and an NDF; GASP2NDF and NDF2GASP, between an image in GASP format and an NDF; GIF2NDF and NDF2GIF, between an image in GIF format and an NDF; IRAF2NDF and NDF2IRAF, between an IRAF image and an NDF; IRCAM2NDF, from an IRCAM data file to a series of NDFs; NDF2FITS, from an NDF to a FITS file; NDF2PGM, from an NDF to a PGM file; NDF2TIFF and TIFF2NDF, between an NDF and a TIFF file; and NDF2UNF and UNF2NDF, between an NDF and a sequential unformatted file. There are also FITS readers in the KAPPA program which convert FITS files to NDFs.
A binary version of CONVERT is available for Linux Intel, DEC OSF, and Sun Solaris platforms. The package is documented in a 44 page user's guide in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
Cook: A make-like program for constructing files and maintaining referential integrity between files. It is given a set of files to create and recipes for how to create and maintain them. Cook can handle Fortran and C sources.
The Cook source code is available. It is written in C and can be compiled on generic UNIX systems. The package is documented in a user's guide available in PostScript format.
[ftp://ftp.agso.gov.au/pub/Aegis/]
[http://sunsite.unc.edu/pub/Linux/devel/make/]
cooledit: An X Window text editor which supports multiple windows. The interface has a 3-D look and feels vaguely like Motif. The features include: an extensible file size limit of 16 Mb, binary file editing, block copy, move, delete, cut, paste, undo, pull-down menus, file insertion, regular expression search and replace, scanf-printf search and replace, shift-arrow text highlighting, mouse text highlighting, macro recording, insert-overwrite toggle, and an option to pipe text blocks through shell commands like indent. It also remembers the state of its desktop when exiting and allows the cycling through many edit windows with a keystroke.
A source code distribution of cooledit is available. It is written in C and requires only the X11 standard libraries for compilation and use. It is documented in a man page.
[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]
Cool: The Classroom Object-Oriented Language is a small language designed for use in an undergraduate compiler course. Cool has many of the features of modern programming languages including objects, automatic memory management, and strong static typing. It was designed to be modular in that there are no dependencies between the assignments, to be highly portable on UNIX platforms, and to be easy to modify and extend (to minimize the work needed to develop new assignments). Cool generates code for the SPIM MIPS simulator.
Distributions of Cool are available for several platforms including DEC Alpha and MIPS, Linux Intel, HP-UX, Sun SunOS, and IBM AIX. The distributions contain an executable of the coolc compiler, assignments, and all documentation. The source code for the compiler is not included.
[http://http.cs.berkeley.edu/~aiken/cool/index.html]
CooL-SPE: The Combined object-oriented Language Software Production Environment is a programming environment designed to support the professional development of large-scale object-oriented application systems. Cool-SPE supports the development of application systems with graphical user interfaces (GUIs) based on Motif with the GUIs being constructed using either a user interface language (UIL) or interactively with a dialog editor. A dialog object class library called DIO is available to facilitate the integration of the application with the X/Motif runtime system. Applications are built using a modern, object-oriented 4th-generation programming language called CooL which features single inheritance, dynamic binding and polymorphism. It also offers generic object types and abstract object types as well as supporting modules in the tradition of Modula to facilitate building large systems.

The CooL language is extended by the CooL library system CoLibri which offers a BCD type and a number of functions for the CooL simple types. It provides foundation object types such as basic file I/O as well as basic container object types such as sets, lists, maps, etc. A source-level debugger called MaX is also provided offers the functionality of the UNIX sdb debugger. It can additionally process (un)conditional breakpoints, tracepoints, resolve inheritance, and dereference pointers. Other features include command history, named command sequences, and an online help facility. A Test Object Interface (TOI) allows the user to carry out quality assurance by providing a runtime frame into which object types can be mounted and interactively executed. Both intermediate results and arguments can be recorded during execution and used as compare targets when running a test battery automatically. An SQL Object Interface (SOI) is provided to allow object-oriented applications to be integrated with a relational database system. This interface offers access to SQL tables via a generated object type interface, and also generates the C program including embedded SQL code for accessing the SQL database.
A source code distribution of CooL-SPE is available. It is written in the Gentle compiler construction language which must be installed to compile and use CooL-SPE. It has been compiled on Linux Intel, Sun Solaris, and SINIX platforms. It is documented in a series of reference manuals available in PostScript format as well as in a set of man pages.
[http://www.first.gmd.de/gentle/examples.html]
[ftp://ftp.fu-berlin.de/pub/unix/languages/cool/]
COOOL: A package of tools for writing optimization code and solving optimization problems, which special interest by the developers in inverse problems. It consists of a library of C++ classes which facilitate in developing optimization codes. It also has a suite of general purpose routines for solving linear and nonlinear inverse problems.
[http://www.cwp.mines.edu/cwpcodes/coool]
coordinate systems: Related software packages include:

GEO-CGM

GEOPACK

GMT

IGRF-95

PROJ

WCSTools
COPS: The Computer Oracle and Password System is a collection of security tools designed specifically to aid UNIX types in the neglected area of computer security. COPS is over a dozen programs that each attempt to tackle a different problem area of UNIX security. These tools check:

file, directory and device permissions and modes;

poor passwords;

the content, format and security of password and group files;

the programs and files in /etc/rc* and cron(tab) files;

the existence of root-SUID files, their writeability, and whether or not they are shell scripts;

a CRC check against important binaries or key files to report any changes;

the writeability of user's home directories and startup files;

the anonymous FTP setup;

unrestricted TFTP, decode aliases in sendmail, SUID uudecode problems, hidden shells inside and rexd running in inetd.conf;

miscellaneous root checks;

dates of CERT advisories versus key files to ensure that the bug is found if present.

COPS also uses the Kuang expert system wherein it takes a set of rules and tries to determine if your system can be compromised. It does not automatically correct any problems it finds but rather merely provides warnings, although there is an option to generate a file containing shell commands that will attempt to fix the problems. A source code distribution is available. Most of the programs are written using the Bourne shell (and related tools) with a few written in C.
[http://www.fish.com/cops/]
Coq: A proof assistant, i.e. a system designed to write formal specifications, programs and to verify that programs are correct with respect to their specifications. A specification language called Gallina is used to represent programs as well as properties of the programs and proofs of the properties. The heart of the Coq system is a type-checking algorithm that checks the correctness of proofs. An interactive proof assistant is also provided to build proofs using specific programs called tactics. Source and binary distributions are available, with one of the latter available for Linux Intel platforms. This is written in Objective Caml and requires an installation of the language for compilation. A user's guide is available in the usual formats.
[http://coq.inria.fr/assis-eng.html]
Coral: A project to develop a robust and efficient deductive database system and to investigate its use in various application domains. Coral is a deductive system which supports a rich declarative language and an interface to C++ which allows for a combination of declarative and imperative programming. The declarative query language supports general Horn clauses augmented with complex terms, set-grouping, aggregation, negation, relations with tuples which contain universally quantified variables, and uses a Prolog-like syntax.
The features of Coral include:

support for many evaluation techniques including bottom-up fixpoint evaluation and top-down backtracking;

a module mechanism wherein modules are separately compiled with different evaluation mechanisms possible in each module;

support for a broad class of programs with negation and set-generation;

support for several data types including numeric and string constants, functor-terms, lists, sets, and multisets;

support for data resident on a disk via an interface with the Exodus storage manager;

a Tcl/Tk package which allows users to examine derivation trees using a GUI; and

an interface to C++ is provided which allows relations defined using the declarative language to be manipulated via C++.

A GUI shell for the entire Coral system written in Tcl/Tk is also available, with which the on-line help facility can be accessed as well.
The source code for the Coral system is available as are binaries for Sun SunOS and Solaris, HP-UX, and Intel Linux platforms. Compilation requires a C++ compiler (g++ will do), the Tcl/Tk packages, and the GNU Readline library. In addition to the on-line help facility, Coral is documented in several technical reports available in PostScript format.
[http://www.cs.wisc.edu/coral/]
Coral (Matlab): A set of Matlab programs designed for analyzing seismic waveform data. These are divided into several categories. The instrument response utilities include:

bb_magn, for calculating Richter magnitudes;

decon_inst, for deconvolving instrument response; and

response, for computing impulse response and transfer functions.

The spherical geometry and coordinate transform utilities include:

coortr, for geocentric/geographic coordinate transformations;

delaz, for computing earthquake/station distance and azimuth;

erot, for making a rotation matrix;

euler_trans, for making an Euler transform rotation matrix;

lld2xyz, for converting lat/lon/depth to Cartesian coordinates;

scrot, for rotating spherical coordinates; and

sph2xyz, for converting spherical polar coordinates to Cartesian coordinates.

Utilities related to time series include:

demean, for removing means from matrix columns;

futterman, implements the Futterman filter attenuation operator;

hilbert_trans, for performing Hilbert transforms;

ift, for inverse Fourier transforms, time shifts and sample interval scaling;

taper, implements Hanning tapers; and

xcor, implements normalized cross-correlograms.

Utilities involving focal mechanisms include:

harvard2xyz, converting moment tensors fro spherical to Cartesian coordinates;

focal_sphere, for plotting point data on a focal sphere;

radpat, for plotting moment tensor nodal lines;

radplt, for plotting focal mechanism nodal lines; and

moment_mag, for Richter magnitudes.

Tools for working with Tau_P travel times include:

get_tt_other, for finding travel time and ray parameters at many offsets;

get_tt_up, for finding travel times for upgoing rays; and

get_ttt, for calculating travel time and ray parameters for the IASP91 model.

Several dozen more scripts are available for reading external files, working with time, general purpose statistical and mathematical manipulations, and other tasks. A source code distribution of this set of Matlab scripts is available. Documentation is via the usual Matlab method.
[ftp://ftp.geophys.washington.edu/pub/out/]
[http://www.geophys.washington.edu/People/Faculty/kcc/coral_tools.html]
Coral Tree Library Set: A collection of libraries that provide a system-independent set of services and functionality, with some services augmented by independently executing daemons. The Library is split into several parts including:

OSD, provides system-independent function calls that map to underlying system calls;

GPL, provides a common baseline general programming language including classes for pointer- and value-based data structures, memory, time, synchronization, strings, files, logging, versions, objects and tuples;

WBA, provides standard semantics for well-behaved applications including standardized access to a GPL logger and WBA environment, a standard printf facility, and standardized execution and exit semantics;

SPA, provides implementations of commonly used algorithms including those for encryption, random numbers, and vectors and matrices;

BLD, a platform independent builder similar to make;

EW, provide an abstraction above windowing and event systems as well as graphics languages including X11, Win32, Xlib and OpenGL;

WDS, a library of derived widgets and related classes built on top of EW;

DNA, implements dynamic network abstractions and provides a common mechanism for communicating across a network;

LM, implements a license management system in software;

DSS, a software-implemented object-based distributed shared memory system; and

DSSX, a set of extended DSS objects.

The entire distribution is available in one package. Smaller groups of modules are also available including:

ctBASE, the base modules required by most higher-level modules;

ctGUI, the window system abstraction and associated widget sets;

ctNET, the network abstraction libraries;

ctBLD, the modules required for the BLD module;

ctDSM, the modules supporting distributed shared memory and other IPC services;

ctMISC, a catch-all category for modules with no other home; and

ctOPEN, all the modules that are currently available as Open Source.

Documentation includes user's and reference manuals in HTML and PostScript format.
[http://www.imonk.com/coraldoc.html]
CORBA: The Common Object Request Broker Architecture is one of the key components of the OMG (Object Management Group) OMA (Object Management Architecture) standard. The OMA consists of an Object Model and Reference Model, with former defining how objects distributed across a heterogeneous network can be described and the latter characterizing interactions between those objects. In the Object Model an object is an encapsulated entity whose services can be access through well-defined interfaces, with the Object Request Broker (ORB) component of the Reference Model responsible for facilitating communication between clients and objects.
The CORBA specification details the interfaces and characteristics of the ORB component of the OMA. The most recent (6/97) version is CORBA 2.0 and consists of several components. The ORB core delivers requests to objects and returns responses to the clients making the requests, all the while hiding the details of the communication process. The OMG Interface Definition Language (OMG IDL) defines interfaces for objects and is similar to C++ classes or Java interfaces. It is language independent and provides a set of types including built-in, constructed, template, and object reference types as well as interface inheritance. The Interface Repository allows the IDL type system to be accessed and written programmatically at runtime, which allows it to support CORBA dynamic invocation as well as be used as a source for generating static support code for applications. Standardized Language Mappings are currently available for C, C++, Smalltalk, and Ada 95 with those for COBOL and the Bourne shell nearing completion and more to come (and some already written by third parties, e.g. for Perl and Eiffel). Stubs and Skeletons play an important role in connecting programming languages to the underlying ORB, with the stub adapting the function call style of its language mapping to the request invocation mechanism of the ORB and the skeleton adapting the request dispatching mechanism of the ORB to the upcall method form expected by the object implementation.

Dynamic Invocation and Dispatch supplies, in addition to the static invocation via Stubs and Skeletons, interfaces for dynamic invocation. The Dynamic Invocation Interface (DII) supports dynamic client request invocation (i.e. a generic stub), and the Dynamic Skeleton Interface (DSI) provides dynamic dispatch to objects (i.e. a generic skeleton). The Object Adapter is an object which adapts the interface of another object to the interface expected by a caller, i.e. an interposed object which uses delegation to allow a caller to invoke requests on an object even if the caller doesn't know the object's true interface. The General Inter-ORB Protocol (GIOP) specifies transfer syntax and a standard set of message formats for ORB interoperation over any connection-oriented transport. See Ben-Natan (1995), Blakley (2000), Mowbray (1997), Otte (1996), and Vinoski (1997).
CORBA related software tools and packages include

ACE,

Arachne,

CorbaScript,

CORBA/SNMP Gateway,

DOME,

Fnorb,

idldoc,

ILU,

JacORB,

Jorba,

MCITT,

ORBacus,

omniORB,

PTool,

ROBIN,

tcliop,

WebbinCMIP.

[http://www.omg.org/]
[http://www.cetus-links.org/oo_corba.html]
CorbaScript: An interpreted object-oriented scripting language whose main functionality is operation invocation onto objects. It is ORB-independent and based on standard CORBA components. CorbaScript manages variables and control flow statements as well as interpreting scripts and construct requests with DII according to information in the scripts. The Interface Repository is used to control parameter types and infers types like CORBA structures, arrays, and sequences. The instruction types available for the scripts include print, assignment, control flow, exception management, and operation call instructions. The scripts handle values and variables with the values capable of being basic objects like integers, floats, or strings; sets of values; the result of an operation invocation on an object; any CORBA typed value composed of an IDL type and a set of values; any expression of values with standard operators; or a CORBA object reference.
A source code version of CorbaScript is available. It is written in C++ and has been compiled on Linux and Solaris platforms using g++ 2.7.2. It is compatible with and uses OmniBroker 2.0. Documentation is available in the form of several technical reports.
[http://corbaweb.lifl.fr/CorbaScript/]
CORBA/SNMP Gateway: A package implementing a gateway between applications in the CORBA domain and SNMP-based network management agents. The gateway dynamically converts method invocation using object references in the CORBA domain to SNMP messages for MIB entries at a remote agent. The gateway consists of several services including:

SNMP Name service, an extension CORBA naming service for navigating the entries of remote MIB;

SNMP Notification service, an extension of CORBA event service to convert SNMP traps/notifications to CORBA events;

SNMP MIB Repository service, and extension of CORBA IFR to obtain meta information about the MIB tables/groups;

SNMP Protocol service, which provides a generic interface to various versions of SNMP protocols; and

an extension of CORBA DSI/DIR to implement the mapping of CORBA operation invocations to SNMP GET/SET messages.

The CORBA/SNMP Gateway packages includes several toolkits including:

an ASN.1/SMI to IDL translator;

a Web-server based on-line MIB to IDL conversion toolkit;

a gateway between management applications in the CORBA domain and network management agents in the SNMP domain;

Java applets for browsing CORBA naming service based name trees;

several Java and C++ examples of using the gateway.

[http://nsm.research.bell-labs.com/~mazum/CorbaSnmp/]
CORE: A collection of C++ classes supporting numerical computations with a variety of precision requirements. In particular, CORE supports the Exact Geometric Computation (EGC) approach to developing robust algorithms. The EGC approach was developed to handle the discrete and combinatorial structures found in geometric (as oppoosed to numeric) computations that have to be handled with extra precision to ensure robustness. Maximizing both precision and efficiency requires that the various parts of a large program use only as much precision as is required, with the parts involving geometric computations requiring more precision than the others. This is generally a tricky thing to accomplish on a case by case basis, so CORE was developed to allow it to be done in a manner that is mostly transparent to the programmer.
The CORE library defines four accuracy levels to meet various needs:

Machine Accuracy (Level 1), a level that can be identified with the IEEE Floating Point Standard 754;

Arbitrary Accuracy (Level 2), specifying any desired accuracy in terms of the number of bits used in the computation;

Guaranteed Accuracy (Level 3), specifying an absolute or relative precision that is guaranteed to be correct in the final results; and

Mixed Accuracy (Level 4), freely intermixing the various precisions at the level of individual variables.

A principle design goal is that a CORE program should be able to be compiled and run at any of the four accuracy levels.
[http://www.cs.nyu.edu/exact/core/]
COSMICS: A package of Fortran programs useful for computing transfer functions and microwave background anisotropy for cosmological models as well as for generating Gaussian random initial conditions for nonlinear structure formation simulations of such models. This package is intended to provide a standard set of numerical tools which can be used by the cosmology simulation community. It generates accurate results of linear evolution which are sufficient for first-order comparison with observations of the microwave background. It can also provide matter distribution input for nonlinear evolution codes.
The package consists of several individual programs including:

LINGER integrates the coupled, linearized, Einstein, Boltzmann and fluid equations governing the evolution of scalar metric perturbations and photons (of both polarizations), neutrinos (massless and massive), baryons, and cold dark matter in a flat Robertson-Walker universe, i.e. it computes the linear evolution of fluctuations generated in the early universe through the radiation dominated era and recombination down to a small redshift input by the user; and

DELTAT integrates the photon transfer functions computed by LINGER to produce photon anisotrophy power spectra; and

GRAFIC normalizes the power spectrum of matter density fluctuations and generates initial conditions needed for nonlinear cosmic structure formation simulations.

The source code for the COSMICS package is available. It is written in Fortran 77 and can be compiled using the g77 compiler. The programs are documented in a user's manual included in the distribution in LaTeX format. A parallel version of LINGER is available which can be used with MPI, PVM, or MPL.
[http://arcturus.mit.edu/cosmics/]
CoST: The Copenhagen SGML Tool is a general purpose SGML post-processing tool. CoST is a structure-controlled SGML application, i.e. it operates on the element structure information set (ESIS) representation of SGML documents. It is implemented as a Tcl extension which works with the nsgmls parser. It provides a flexible set of low-level primitives upon which sophisticated applications can be built, including:

a powerful query language for navigating the document tree and extracting ESIS information;

an event-driven programming interface; and

a specification mechanism which binds properties to nodes based on queries.

A module called Simple is available which provides a simplified, high-level interface for developing translation specifications. It automatically handles a large number of simple types of translations to ease the use of a powerful but somewhat complex system. The RATFINK library of Tcl routines for generating RTF output includes a CoST script for converting SGML to RTF.
The source code for CoST is freely available. Installation and use requires sgmls, Tcl 7.4, [incr Tcl] 2.0, and optionally Tk and TclX. The package is documented in a user's manual available in HTML and PostScript formats.
[http://www.flightlab.com/cost/cost.html]
[ftp://info.ex.ac.uk/pub/SGML/cost/]
COST: The Coupled Oscillator Simulation Tool provides the numerical tools and a graphical user interface (GUI) for the simulation of coupled systems of identical oscillators. It is mainly intended for those working on coupled oscillator systems and their symmetry properties in applied mathematics and engineering. Three elements define a coupled system: cells, which are given by an ODE typically of low dimension; coupling matrices, which give the pattern of the coupling as defined by a Boolean matrix; and coupling maps, which describe the function that couples a pair of cells if they are connected. Thus a coupled system is defined by a cell (type), the number of cells, and a list of couplings. Each of these key elements is represented by an abstract class describing its functionality.
A source code distribution of COST is available. It is written in C++ and requires both CODE++ and InterViews for compilation and use. See the CODE++ entry for further information about compilation on Linux platforms. The classes are described in both HTML and PostScript format, with a terse user's guide also available in HTML format.
[ftp://ftp.zib.de/pub/Packages/code++/]
Cougaar: A large-scale agent architecture project that provides a framework to implement distributed agent applications with minimal consideration for the underlying architecture and infrastructure. The Cougaar architecture was designed as a foundation for a large-scale, globally distributed system. The model extends agent technoogy via the implementation of a cognitive model of human thinking and interaction that attempts to emulate the mental processes of perception, memory, judgment, reasoning and decision making. The features of the Cougaar architecture include:

a distributed global plan (similar to a partitioned blackboard) that is interconnected but not replicated across the agent society such that information is shared only among interested parties and efficiently managed through a publish and subscribe mechanism;

a modular design consisting of Logic Providers from which services and capabilities are composed and Plugins that encapsulate agent behaviors;

a human cognitive model in which the way people actually perform planning is reflected in how agents perform planning, with the latter accomplished via four component patterns called a Task Expander, Task Allocator, Assessor and Data Manager;

execution monitoring and dynamic replanning to allow for replanning of original plans as they are affected by the real world;

a powerful workflow representation supporting decompositions among tasks, constraints, linkages to other tasks, triggers, and alerts;

an efficient publish and subscribe design that ensures information is available where it needs to be as soon as it can be delivered, but no further;

explicit consideration for large-scale performance issues;

time-phased asset schedules that detail the assignments and roles of an asset over time;

a Plugin API that allows domain behaviors to access services and publish information into the global plan without individual Plugins having to know about other behavior implementations;

transaction level persistence wherein each agent independently persists its information;

a suite of general purpose Plugins, e.g. an SQL/JDBC interface, a table-based dispatcher, an expert system, a simple scheduler, an inventory manager, and a demand generator;

a Plan Service Provider (PSP) Plugin that acts as a portal to information in each cluster, e.g. seamlessly rerouting to information if it is not available in a target agent as well as handling most of the traversal and formatting of information;

clean separation of architecture from domain specific business processes;

support for the incorporation and propagation of an arbitrary set of policies among an organization of agents or the entire society to modify the behavior of Plugins;

event triggers and alerts activated by changes in the plans or data relating to the plans; and

negotation capabilities using preferences and penalty functions.

The Cougaar distribution is written in Java and is available in several parts under an open source license. Several pieces of documentation are available in PDF format.
[http://cougaar.alp.isotic.org/]
Counterpoint: The Counterpoint project has apparently been transmogrified (sometime around 10/99) into a project called Paraslax, i.e. a set of Java packages implementing distributed shared objects.
COUPLE: A Fortran 77 program which performs a stepwise coupled mode calculation of the 2-D underwater acoustic field due to a vertical array of harmonic point or line sources in, respectively, cylindrical or plane geometry. The environment can be range dependent, i.e. consist of a series of horizontally stratified fluid filled regions. Each region is assumed to have a piecewise linear depth variation in the index of refraction squared in the water and sediment layers as well as an exponential depth variation in the sediment density. The index of refraction in the sediment may be complex to allow for attenuation.
The features of COUPLE include:

modal calculations in each of the regions via a search or Galerkin procedure;

finding complex eigenvalues using a search procedure based on Newton's method if the water and sediment layers are homogeneous with only the depth varying with range;

use of a Galerkin matrix method in the more general case of inhomogeneous water and sediment layers, range dependent material properties, and range dependent bathymetry; and

use of a decoupling algorithm to solve the matrix two-point boundary value problem in range which occurs in the stepwise coupled mode formulation (i.e. a procedure that eliminates the numerical instability that occurs with shooting methods).

A source code distribution of COUPLE is available. It is written in Fortran 77 and documented within an ASCII user's guide as well as via comment statements contained within the source code files. See Evans (1983), Evans (1986), and Evans and Gilbert (1985).
[ftp://oalib.njit.edu/pub/couple/]
Courier: A modular, multiprotocol mail MTA (mail server) designed to strike a balance between performance, flexibility and features, the latter of which include:

configurability as an intermediate mail relay or a end server;

use of maildir as the native storage format;

mailbox access via POP3, IMAP or HTTP via integrated servers;

a full-featured mailing list manager;

SOCKSv5 support, i.e. sending but not receiving through a firewall;

PAM, LDAP or MySQL authentication;

a gateway to/from UUCP;

delivery status notifications;

authenticated SMTP;

ESMTP extensions (e.g. XVERP and XEXDATA);

DNS-based blacklists;

integrated mail filtering via an API for installing arbitrary external mail filters;

partial support for importation of sendmail alias files and Qmail .qmail files;

setting a maximum number of messages to simultaneously deliver to the same host; and

specifying a backup relay and having temporarily undeliverable mail offloaded to a backup server.

Installation and use requires a C++ compiler and Perl 5.
[http://courier.sourceforge.net/]

Courier-IMAP

A server for providing IMAP access to maildir mailboxes. This is the IMAP server included in Courier as made available separately. The features include:

abstract authentication modules;

virtual mailbox support;

restricting the maximum number of IMAP logins as well as the maximum number of logins from the same IP address; and

shared folder support.

[http://www.inter7.com/courierimap/]

maildrop

A mail delivery agent with filtering capabilities. This is the agent included in Courier as made available separately.
[http://www.flounder.net/~mrsam/maildrop/]

SqWebMail

A web CGI client for sending and receiving email using maildir mailboxes. This is the server included in Courier as made available separately. The features include:

support for hierarchical mail folders;

virtual accounts;

LDAP and vpopmail authentication;

inline display of image attachments; and

extensive MIME support.

[http://www.inter7.com/sqwebmail/]
COW: A Web-based bulletin board system written using Perl.
[http://calypso.rs.itd.umich.edu/COW/about.html]
COX: The C with Operator eXtensions is a language in which C has been extended in various ways to facilitate operator overloading and general object oriented programming. COX is upward compatible with C and supports a general operator concept. The language extension concepts include a general operator concept with almost arbitrary operator names and in which the meaning and precedence of operators may be overloaded. Argument and result types may also be overloaded and floating point literals have the additional result type char. Other features include a new data type aggregate, constructors and destructors, the possibility of different constructors and destructors for temporary variables, references, a distinction between read and write access of values, named loops, support for vector-like literals with typed open parameter lists, templates, attributed types for distinctive template overloading, and generic declarations using typeof(expression).
The COX package is available in source code format or in binary form for Linux Intel, Sun Solaris, and OS/2 platforms. It is (rather sketchily thus far) documented in a user's guide in Texinfo and HTML formats.
[ftp://ti3sun.ti3.tu-harburg.de/pub/cox/]
cpio: A program to manage archives of files. This is the GNU version which supports the features of the System V release 4 cpio, including support for tar archives. This package also includes rmt, the remote tape server, and mt, a tape drive control program. The March 1996 issue of the Linux Journal has an article entitled ``cpio: A Multipurpose Archive Tool'' by Eric Goebelbecker (for which an online version is available).
[http://www.gnu.ai.mit.edu/order/ftp.html]
CP/M: An operating system for 8-bit computers that resembles a less user-friendly version of DOS, an unsurprising coincidence seeing how DOS was copied from CP/M around 1980. CP/M was available in three main versions - 1.4, 2.2 and 3.1 - with 2.2 being the basis of MS-DOS and 3.1 the precursor to DRDOS and OpenDOS. CP/M versions were also developed for 8086 and 68000 processors, with CP/M-86 being the basis for DOS Plus, Concurrent DOS and REAL/32.
[http://www.seasip.demon.co.uk/Cpm/]

cpmio

A console I/O library for CP/M under UNIX. This supports MYZ80 style multiple terminal emulations.
[http://www.seasip.demon.co.uk/Cpm/software/linux.html]

cpmredir

A filesystem emulation library for CP/M emulators under UNIX. This supports the use of directories on the host system as CP/M drives.
[http://www.seasip.demon.co.uk/Cpm/software/linux.html]

Z80 CP/M

A CP/M compiler for a Z80-based system. This can be implemented as a cross-compiler on UNIX systems with zxcc.
[http://www.hitech.com.au/software/cpm/]

zxcc

A wrapper for the Z80 CP/M compiler that allows it to be used as a cross-compiler on UNIX systems. This also requires the use of the cpmio and cpmredir packages.
[http://www.seasip.demon.co.uk/Cpm/software/linux.html]
cPost: A program that creates a PostScript file from a set of C source code files. The PostScript file contains the contents of the input files marked up such that various parts are highlighted.
[http://metalab.unc.edu/pub/Linux/devel/lang/c/]
cpp: The C PreProcessor is a macro processor used automatically by the GCC compiler to transform a program in various ways before it is compiled. The GNU cpp provides a superset of the features of ANSI Standard C. It is called a macro processor because it allows macros, i.e. brief abbreviations for longer constructs, to be defined. Four separate facilities can be used separately or in some combination. These are:

the inclusion of header files containing declarations to be substituted into a program,

the aforementioned macros,

conditional compilation in which certain parts of a program can be included or excluded according to various conditions, and

line control which can be used to inform the compiler of where each source line originally came from (if a program is used to combine or rearrange source files into an intermediate file).

The GNU cpp is included in the GCC distribution and is automatically invoked whenever a program is compiled with it. It can also be invoked separately via the cpp command. It is documented in a user's manual available in standard Texinfo format. See also the separately available GNU m4 macro processor.
[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://sunsite.unc.edu/pub/Linux/GCC/]
cppf77: A package which implements a standard for portable, mixed C++/Fortran 77 programming. The requirements this package attempts to meet are that: the mixed programs must be as portable as their Fortran-only ancestors, a single source code must be used on all platforms, calling F77 from C++ must be easy and straightforward and not significantly more difficult than calling F77 from itself, mixed code must not induce any significant performance penalty, all major F77 features must be supported from C++, and calling F77 from C++ should be done without changing the F77 code.
[http://home.sol.no/~arnholm/]
CppIma: A C++ library designed for image processing tasks. It is a way to provide an interface from C++ to common operations on images whose primary goal is to enable the easy construction of image processing programs. A secondary goal is to create an API independent of the actual image processing library used. To this end CppIma currently (3/97) suports three different image processing libraries: the ima library (of which a simple version is included in the CppIma package); the Khoros package library; and the SCIL-Image package library.
The CppIma distribution includes the source code which is written in C++. It should compile with g++ as well as with Cfront-based compilers. The documentation is contained within a user's guide available in HTML format online.
[http://www.ph.tn.tudelft.nl/~klamer/cppima.html]
cppp: A C++ parsing and semantic analysis program and library. This parses standard C++ including exceptions but excluding most template syntax. It can also check for semantic errors and performs symbol resolution (i.e. resolving names to the objects to which they refer). It can traverse the resulting abstract syntax tree and/or dump the tree to standard output. This can be used as either a program or a library.
[http://www.cs.brown.edu/software/catalog.html]
CPQR79: A Fortran routine which computes all zeros of a polynomial of arbitrary degree with complex coefficients by computing the eigenvalues of the companion matrix. A related routine called RPQR79 exists in the package for the case of real coefficients. This routine is an interface to an eigenvalue routine in the EISPACK library. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
cproto: A program that generates C function prototypes and converts function definitions. The function definitions can be in the old style or ANSI C.
[http://metalab.unc.edu/pub/Linux/devel/lang/c/]
CPZERO: A package of Fortran subroutines for finding all the zeros of polynomials with either real or complex coefficients. The routine CPZERO is for complex and RPZERO for real coefficients. These programs also provide estimates of the errors in the estimates of the zeros. The method used is Newton's method applied to the system obtained by setting the polynomial coefficients equal to the symmetric functions of the roots.
The source code for CPZERO is available. It is written in Fortran and its use is documented in comment statements within the source code. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
CQL++: An ANSI and ODBC compliant database management system (DBMS). CQL++ is a complete SQL and B-tree/ISAM DBMS that provides a single user or client/server solution for all machines and operating systems. The major features of CQL++ include:

an ODBC driver;

a C++ class library for performing all SQL and ISAM operations from within C++ programs;

support for transaction processing including commit and rollback, nested transactions, and logging and failure recovery;

support for client/server processing over a heterogeneous network;

SQL or ISAM interfaces with ISAM access available for SQL base tables;

support for variable length data and keys;

sixteen supported data types;

compliance with ANSI 1989 Level 2 SQL with integrity enhancement and ODBC level 1 API and extended language level;

TCP/IP networking among heterogeneous machines;

fully dynamic SQL wherein all statements can be constructed at runtime and executed dynamically;

a preprocessor that converts C++ files with embedded SQL statements into C++ files; and

support for ANSI privilege and security features.

A source code distribution is available under the GPL.
[http://www.cql.com/]
CrackLib: A library containing C programs which attempt to prevent users from choosing easily guessed passwords by filtering them out at the source. It checks all the passwords in the password file against words in a dictionary that have been encoded with the same algorithm as were the passwords. The same original string as the password will encode into a string identical to that of the original password's encoding. It doesn't take modern computers very long to compare some really large dictionaries to the passwords in a file so this is a reasonably effective security technique. A version of this modified for shadow passwords can be found in the Shadow Ina Box tool suite.
[http://metalab.unc.edu/pub/Linux/system/security/
CRDtools: A collection of tools providing data extraction, analysis and visualization capabilities for the climate researcher. The file extraction tools include those for selecting datasets by attributes, adding entries to a data dictionary, reading and writing NetCDF format files, viewing the metadata for NetCDF files, and merging NetCDF files. The visualization tools include those for drawing an image using Xlib routines. Xlib is also used for drawing scrollable time graphs and scatterplots. Plots created using NCAR graphics include contour and time plots as well as graphs of spectra. Among the analysis tools available are those that compute annual data means and long-term composites, calculate correlation and regression coefficients, perform spectral analysis, perform arithmetic operations on multiple files, and perform smoothing and interplation of file data.
The CRDtools software is written in C and Fortran. The source code is available as well as a binary for platforms running Sun Solaris. The source can be compiled on platforms with C and Fortran compilers as well as either OpenWindows or the XView library. The make file includes targets for Sun and Mips machines and can probably be modified without major effort to compile the thing on a Linux box, especially since the XView library is readily available in both source and binary form for Linux systems. The documentation is contained within several internal help files that can be used from within the system. See the CRDtools Installation Guide for instructions on how to obtain it.
[http://www.cdc.noaa.gov/cdc/crdtools/ crdtools.html]
[http://www.cdc.noaa.gov/~crdc/crdtools/install.shtml]
C-Refine: A preprocessor for programs written in C, C++ or other similar languages. This introduces an additional language construct called refinement that allows further decomposition with symbolic names inside functions - a construct that makes programs easier to read and modify. The crefine preprocessor program converts programs written in C-Refine, C++-Refine and Objective-C-Refine into normal C, C++ and Objective-C programs. A source code distribution is available. It is written in C and documented in a couple of man pages.
[http://wwwipd.ira.uka.de/~prechelt/sw/]
Cricket: A high performance and flexible system for monitoring trends in time series data. It was developed to aid network managers in visualizing and understanding traffic on their networks. It was also a response to weaknesses in MRTG, e.g. a config file that gets unwieldy and overly complex with too many purposes and/or targets. A hierarchical configuration system called a config tree is used in which information stored high in the tree is inherited by all the leaves. The two main components of Cricket are a collector and a grapher. The collector uses the RRD TOOL to store collected information in a database, and the grapher produces graphs of the data for viewing via the Web.
[http://www.munitions.com/~jra/cricket/]
CritSuite: A suite of critical discussion tools for the web. CritSuite consists of three pieces of integrated software:

CritLink, which enables the universal annotation of documents on the Web;

CritMap, which allows the Web to be navigated using a graphical interface by displaying a central, focus document and each of the hypertext links connecting to that document;

CritMail, a newer version of Hypermail that converts email archives into Web documents in which quoted text is linked to its original location.

All the programs are written in Perl 5 and all are available as source code. Documentation is currently (8/98) a bit sketchy.
[http://crit.org/http://crit.org/index.html]
Crowds: A system for protecting privacy while browsing the Web. Crowds prevents web servers you visit from learning information that can be used for identification. If does this by grouping users into a large and geographically diverse group that collectively issues requests on behalf of its members. Basically, a request from any member is processed such that it is actually sent by a randomly chosen other member, i.e. the most that can be ascertained is that someone in the Crowds group sent a specific request. A proxy running on local machines executes the Crowds protocol, so participating in Crowds simply requires tarting the proxy and setting your browser to use it as a proxy. The creators of the Crowds software have a group that can be joined or a new group can be created with the available server software. A source code distribution of Crowds is available. It is written in Perl and requires version 5.004 or greater.
[http://www.research.att.com/projects/crowds/]
cryptlib: A security toolkit that allows even neophytes to easily add encryption and authentication security services to software. A high-level interface allows such capabilities to be added to an application in as little as half an hour by masking all of the low-level details. The features include:

a transparent and consistent interface to a number of widely-used encryption algorithms and systems including a higher level interface to digital signature and encryption key management routines;

extensive self-testing against test data from encryption standards and reference implementations upon initialization;

compliance of all algorithms with recognized security or encryption standards including Blowfish, CAST-128, DES, Triple DES, Diffie-Hellman, DSA, HMAC-MD5, HMAC-SHA1, IDEA, MD2, MD4, MD5, MDC-2, RSA, RC2, RC4, RC5, RIPEMD-160, SHA/SHA1, and Safer/Safer-SK;

full X.509 certificate handling with support for all X.509v3 and IETF PKIX certificate features as well as support for SET, Microshaft AuthentiCode, S/MIME and SSL client and server certificates;

a complete public and private key management interface which allows keys to be stored in and retrieved from a wide variety of key database types;

information protection features including denial of user access to sensitive information, memory management by cryptlib for all encryption objects, and memory locking of sensitive information; and

development entirely outside of the U.S. and therefore not covered by paranoid U.S. export restrictions.

A source code distribution is available which can be used on almost all available platforms and with most C compilers.
[http://www.cs.auckland.ac.nz/~pgut001/cryptlib/]
cryptography: Packages dealing with cryptography include:

CIPE, a project to build encrypting routers;

cryptlib, a security toolkit for adding encryption and authentication security services to softwware;

CryptoLib, a portable and efficient library of primitives for building cryptographic applications;

CryptoPine, for using PGP inside of Pine;

Crypto++, a C++ class library of cryptographic primitives;

Fortify, upgrades export-grade Netscape browsers to full-strength, 128-bit cryptography;

FreeLIP, a large integer programming package for prototyping and experimenting with number theory-based cryptographic protocols;

Kerberos, a network authentication system based on the key distribution model;

mcrypt, a replacement for the UNIX crypt program;

MD5, a program that calculates a message-digest fingerprint or checksum for a file;

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

PGP, a program for electronic mail privacy;

premail, a program for the transparent encryption of email;

Privtool, a PGP-aware replacement for the standard mailtool program;

RSAEuro, a version of the RSA reference toolkit for non-US users;

SECUDE, a security toolkit incorporating well-knonw symmetric and public-key cryptography;

SESAME, a toolkit for building security infrastructure components using cryptographic protection;

SRP, a mechanism for performing secure password-based authentication and key exchange over any type of netwolrk;

SSLeay, an implementation of the software encryption protocol of Netscape; and

SSLRef, the Netscape implementation of its software encryption protocol.

Sites with useful security and encryption information include:

Dictionary of Technical Cryptography
[http://www.io.com/~ritter/GLOSSARY.HTM]

Cryptography and Security Links
[http://theory.lcs.mit.edu/~rivest/crypto-security.html]

Center for Democracy and Technology
[http://www.cdt.org/crypto/]

CERIAS
[http://www.cerias.purdue.edu]

CryptoWeb
[http://itrc.on.ca/CryptoWeb/]

CypherNet
[http://www.cypher.net]

European Cryptography Resources
[http://www.modeemi.cs.tut.fi/~avs/eu-crypto.html]

NIST Security Clearinghouse
[http://csrc.ncsl.nist.gov/]
CryptoLib: A portable and efficient library of primitives with which cryptographic applications can be built. It is intended for research and experimental use and is distributed without warranty or support. The functionality of CryptoLib includes:

arbitrary length bignums;

a bigmath package;

many cryptographic primitives include DES, 3DES, Diffie-Hellman, DSA, El Gamal, Rabin, MD2, MD4, MD5, RSA and SHA; and

support functions.

A source code distribution is available. It is written in C and can be compiled on most platforms.
[ftp://idea.sec.dsi.unimi.it/pub/security/crypt/math/]
Crypto++: A free C++ class library of cryptographic primitives. Crypto++ contains:

symmetric block ciphers, e.g. IDEA, DES, DES-EDE, RC5, Blowfish, Diamond2, TEA, SAFER, 3-WAY, GOST, SHARK, CAST-128 and Square;

generic cypher modes, e.g. CBC, CFB, OFB and counter mode;

stream ciphers, e.g. SEAL, WAKE, Sapphire and BlumBlumShub;

public key cryptography, e.g. RSA, DSA, ElGamal, Diffie-Hellman, BlumGoldwasser, Rabin, LUC, LUCDIF, LUCELG and Elliptic Curve Cryptosystems;

padding schemes for public key systems, e.g. PKCS1, OAEP and PSSR;

one-way hash functions, e.g. SHA, MD5, HAVAL, RIPE-MD160 and Tiger;

message authentication codes, e.g. MD5-MAC, HMAC and XOR-MAC;

hash functions as ciphers, e.g. Luby-Rackoff and MDC;

pseudo-random number generators (PRNG), e.g. ANSI X9.17 appendix C and PGP's RandPool;

Shamir's secret sharing and Rabin's information dispersal scheme;

gzip-compatible compression and decompression;

fast multi-precision integer operations;

prime number testing and generation;

various miscellaneous modules, e.g. base 64 coding and 32-bit CRC;

a high-level interface for the above using a filter/pipeline paradigm and;

benchmarks and validation testing.

A source code distribution of Crypto++ is available. The most recent (6/98) version (2.3) can be compiled using egcs. This can be found in the LIBS/wedai subdirectory at the source location indicated on the site.
[http://www.eskimo.com/~weidai/cryptlib.html]
Crystal Space: A 6 degrees-of-freedom 3-D engine based on the portal technology. The features include:

a true 6 degrees-of-freedom engine with arbitrary sloped convex polygons;

a visibility system based on a combination of portals, BSP trees and a coverage buffer;

perspective correct texture mapping with interpolation every 16 pixels;

mipmapping to minimize memory strain on the texture cache;

support for loading GIF, TGA, PGN and JPEG textures;

mapping a texture on a polygon in various ways including rotated, scaled and mirrored;

moving objects and a script language to control the movements;

transparent and semi-transparent textures;

static lighting with shadows;

support for mirrors which, along with alpha mapping, allow the creation of shiny and reflecting surfaces;

a pseudo-radiosity system (precalculated);

a dynamic gouroud shaded sky dome for a realistic sky;

configurable colored lighting;

depth-corrected volumetric fog in sectors;

a hierarchical bounding box collision detection system;

sound and networking support;

optional Glide and OpenGL hardware acceleration;

optional MMX support;

dynamic and dynamic moveable lighting;

3-D triangle mesh sprites with frame animation;

support for 8- and 15/16-bit displays and for internal 24-bit textures with private colormaps for each texture;

direct loading of 3DS or Quake MD2 models;

optional MMX support; and

an ASCII world file format for easily redefining worlds.

A source code distribution of Crystal Space is available. It is written in C++ (with assembler optionally available). Documentation is still (6/98) a bit sketchy but a FAQ and some other information are available.
[http://crystal.linuxgames.com]
CSA: Comprehensive System Accounting is a set of programs and shell scripts that provide methods for collecting per-process resource usage data, monitoring disk usage, and charging fees to specific login accounts. CSA takes the per-process accounting information and combines it by job identifier within system boot uptime periods.
CSA features not provided in other accounting packages include:

per-job accounting;

daemon accounting (e.g. tape, batch and workload management systems);

flexible accounting periods;

flexible system billing units;

offline archiving of accounting data;

user exits for site-specific customization of daily and periodic accounting;

configurable parameters; and

a user job accounting program.

[http://oss.sgi.com/projects/csa/]
cscope: A developer's tool for browsing C/C++ code whose features include:

searching code for all references to a symbol, global definitions, functions called by or calling a function, test strings, regular expression patterns, files, and files including a file;

a curses-based interface;

an information database generated for faster searches and later references; and

a fuzzy parser that fully supports C as well as parts of C++ and Java.

A source code distribution is available under the BSD license, and binary versions are available for Linux platforms.
[http://cscope.sourceforge.net/]

cbrowser

A GUI for cscope that provides a full-featured browser with syntax highlighting and full text searching. The additional features include:

a query history;

aborting long queries; and

a function call hierarchy/viewer.

[http://www.ziplink.net/~felaco/cbrowser/]
CSDP: The C library for SemiDefinite Programming is a library of routines which implement a predictor-corrector variant of the semidefinite algorithm of Helmberg, Rendl, Vanderbei, and Wolkowicz. This makes effective use of sparsity in the constraint matrices, includes support for both linear equality and linear inequality constraints, and also includes support for general sparse matrices. The code is written in C with Fortran subroutines used for linear algebra. The source code is available as is a user's manual in PostScript format. See also INCT, LMITOOL, MAXDET, SDPA, SDPpack, SDPSOL, and SP. See () and ().
[http://www.nmt.edu/~borchers/csdp.html]
csh: The C SHell, written by William Joy at Berkeley, was designed as a programmer's shell whose syntax was similar to that of C. It is usually installed as /bin/csh and also usually not recommended, a situation reflected in the title of a notorious document, i.e. ``csh considered harmful.'' It is less suitable than other well-known shells for extensive programming tasks due to an awkward command history implementation and the lack of command completion and command-line editing. A later version called tcsh added command-line editing and some other improvements, and on some systems /bin/csh is a symbolic link to /bin/tcsh. Neither of these is backward compatible with the Bourne shell (sh), the precursor to most modern shells. Joy's original introduction to csh can be found as:

An Introduction to the C Shell
[http://www.softlab.ntua.gr/unix/docs/csh.txt]
CSML/MCB: A package that takes a description of a finite state machine in a high level language and produces a finite state machine as output. The components of CSML/MCB include:

csml, which translates a program in the CSML (Compositional State Machine Language) into the corresponding finite state machine;

ltd, translates a program in SML (state machine language) into the corresponding finite state machine;

smc, a program for composing modules generated by CSML;

mcb, a model checker for CTL formulas; and

a wide range of example programs.

A source code distribution of this C package is available. It is documented in a set of man pages.
[http://www.cs.cmu.edu/~modelcheck/csml.html]
Csound: A software sound synthesis package which reads some files containing various notation and creates a soundfile which is either stored on disk or played in real time. The two main files which are read by Csound contain the score and an orchestra. The score is an event list for scheduling events, and the orchestra defines how the events will be synthesized. An orchestra is composed of instruments which are processes triggered by the notes, i.e. events, in the score. The instruments in a Csound orchestra are defined in a simple syntax which invokes complex audio processing routines. Newer features of Csound include phase vocoder and FOF synthesis modules and a MIDI converter and control units which enable Csound to be run from MIDI score files as well as from external MIDI keyboards.
The source code for Csound is available. It is written in mostly ANSI C and can be compiled on many generic UNIX platforms. The system is documented in a user's manual available in PostScript and HTML formats.
[http://www.leeds.ac.uk/music/Man/c_front.html]
[http://music.dartmouth.edu/~dupras/wCsound/csoundpage.html]
[http://www.firstpr.com.au/csound/]
CSP: A package that implements a web server environment using C/C++ for the scripting language. This supports a Linux/Apache serving environment and allows for interpreted C/C++ code that can be compiled for script hiding and speed. This is written on top of the CINT interpreter. A loadable CSP module called libasp provides a collection of C++ ojects with an interface similar to ASP, allowing developers with an ASP site to migrate to a CSP-based system in which back end objects do not need to be encapsulated in COM. In other words, independence can be had from a certain commercial web server.
[http://ruby.ddiworld.com/jreed/web/csp/]
CSS: Cascading Style Sheets are a style sheet mechanism designed specifically to allow Web designers and users set fonts, colors, white space, and other presentational aspects of a hypertext document. They allow authors and readers to influence the presentation of documents without sacrificing device-independence and without adding new HTML tags. The browsers which support CSS as of 5/97 include: Netscape Navigator 4.0, Emacs-w3, and (partially) Arena. An authoring tool which supports CSS is Amaya.
[http://www.w3.org/pub/WWW/Style/]
CSSC: A workalike replacement for the SCCS (Source Code Control Suite) software package. It is a faithful reproduction of SCCS although some features, e.g. binary file support, are not yet (8/97) available. This test release contains a test suite and is aimed at getting CSSC tested on as many platforms as possible. It is recommended that new users try RCS rather than this since it is mainly intended as a drop-in replacement for SCCS.
[ftp://alpha.gnu.ai.mit.edu/pub/gnu/CSSC/]
[http://www.free-lunch.demon.co.uk/CSSC/]
C*: An explicitly parallel language developed by Thinking Machines for which a compiler has been designed and built at the University of New Hampshire. The compiler translates C* code into C code plus calls to a communication library at points where data transfer among processors is required.
The distribution includes the source code which is written in C. Documentation is separately available via several technical reports in PostScript format. The current (version 3) C* system should run on most UNIX workstations (including Linux). It also runs on networks of machines using PVM 3.x, the IBM SP-2, the nCUBE-2, and on multiprocessor Suns and DEC Alphas using multithreading. It will also run on Linux networks using the UNH Net* system (which is available in a subdirectory of the C* directory). Perl and an ANSI C compiler are needed to compile the system.
[ftp://ftp.cs.unh.edu/pub/cstar/]
cstream: A general purpose stream-handling tool similar to the UNIX dd command. The features include:

sane command line switch syntax;

exact throughput limiting on the incoming side (wherein timing variances in early reads are counterbalanced in later reads);

precise throughput statistics reporting;

clean shutdowns before EOF via SIGHUP with timing information displayed;

support to write the PID to a file for sending of these signals;

support for fifos, e.g. a pseudo-device that sinks or delivers data but looks like a file; and

data creation and sink so /dev/null and /dev/zero are not required.

[http://www.cons.org/cracauer/cstream.html]
C-Talk: An object-oriented language with statically-checked strong typing, multiple inheritance, parameterized classes, exceptions, multitasking and persistent objects. C-Talk is a high-level language designed for the development of large and complex software systems. It inherits the best features of such languages as C++, Smalltalk, Lisp and CLU. C-Talk programs are made more reliable by static and dynamic type checking, index range checking, the lack of a pointer notion and garbage collection instead of explicit memory deallocation. The object-oriented approach along with a fast incremental compiler that produces bytecode accelerates the development cycle of large systems. A simple interface between C-Talk and C++ allows the implementation of critical pieces of code requiring high performance to be written in C++. A source code distribution of C-Talk is available. Documentation is contained in a language reference manual in PostScript format.
[http://www.ispras.ru/~knizhnik/]
CTC: A collection of PGP-compatible C routines that provides all the cryptographic, compression and file formatting functions needed to write PGP-compatible applications. CTC development goals included interoperability with PGP, machine and compiler independence, extensibility, a minimum of license and patent restrictions, modularity, and ease of auditing. The library consists of a set of separate modules including application callable modules, internal modules, and machine dependent modules.
The CTC application callable modules are, as the name suggests, the ones that should be called by applications. They include:

armour, which provides ASCII-armor coding and decoding;

bignums, which provides multiple precision positive integer arithmetic;

keyhash, which provides key management; and

ctc, which provides high-level encryption and decryption functions.

The internal modules should not be used for direct calling from applications. They include cipher-control modules, which control which algorithms are executed at run-time. The machine dependent modules are those that need to be provided by the application. These modules provide user interaction and condition reporting functions, file access, true random number generation, and user interrupt detection. Standard C implementations of these are provided in the package.
A source code distribution of CTC is available. A user's manual is included in the distribution.
[http://www.bifroest.demon.co.uk/ctc/]
[http://www.geocities.com/SiliconValley/1394/]
Cthreads: A user-level threads package that runs on several uniprocessors and multiprocessors. Cthreads offers support for shared-memory parallel programming. A source code distribution of Cthreads is available which has been successfully installed on several platforms including Linux Intel. Several technical reports are available as documentation.
[http://www.cc.gatech.edu/systems/projects/Cthreads/]
Cthugha: An oscilloscope on acid, Cthugha is an oscilloscope program which takes a sound card's CD, line, or microphone input and displays it as a swirling, hypnotic, 256-color acid trip. The source code is available as are binaries for various platforms including Linux Intel.
[http://www.afn.org/~cthugha/]
CtrlLAB: A Matlab-based control laboratory tool containing programs which provide a graphical interface for performing feedback system analysis and design tasks. The capabilities of CtrlLAB include:

interactively entering models (including SIMULINK modeling);

model display;

system state space realization;

model reduction using various algorithms;

system analysis in the frequency, complex, and time domains;

graphical display and figure editing and manipulation;

a matrix viewer and editor; and

PID tuning and display facilities.

The package is documented in 45 page user's manual in PostScript format.
[ftp://ftp.mathworks.com/pub/contrib/v4/control/ctrllab/]
CTSim: An open source Computed Tomography Simulator. CTSim simulates the process of transmitting X-rays through phantom objects and reconstructs the original phantom image from the projections using a variety of algorithms. It also contains a wide array of image analysis and processing functions. The features include:

several standard built-in phantom objects and the capability of loading others from ASCII files; and

cross-platform compatible file formats for projection and image data.

The programs comprising the package include:

ctsim, a GUI for most of the rest of the functions;

phm2if, generates an image file of a phantom object;

phm2pj, simulations the collection of CT data, i.e. projections, of a phantom object;

pjrec, performs a CT reconstruction;

pj2if, converts projection data to a raw sinugram image;

pjinfo, shows information about a projection file;

ifexport, converts an image file to a variety of 8- and 16-bit image formats;

if1, performs operations on a single image file;

if2, performs operations on two image files, e.g. comparisons; and

ifinfo, shows statistics and history labels of image files.

[http://www.ctsim.org/]
CTWM: An extension of the TWM window manager that features up to 32 virtual screens called workspaces. Each workspace can be distinguished by choosing a unique pixmap for its root window and with colors and names for its associated WorkSpaceManager widgets. Other features of CTWM include:

optional 3-D window titles and borders;

simultaneous existence of windows in selectable workspaces;

a workspace map to allow quick movement among them;

animated widgets and root backgrounds;

pinnable and sticky menus;

optional state-aware m4 preprocessing of the .ctwmrc init file;

uses on the standard X11 libraries;

a documented and backwards-compatible superset of TWM; and

full, tabbed, or no titlebars per window.

A source code distribution is available that is easily compiled on standard UNIX/X11 platforms.
[http://www.plig.org/xwinman/ctwm.html]
c2hs: An interface generator for simplifying the development of Haskell bindings to C libraries. This tool reads existing C header files that determine data layout and function signatures and generates Haskellmodules specifying type signatures and marshalling details.
[http://www.cse.unsw.edu.au/~chak/haskell/c2hs/]
c2j: A C to Java translator.
[http://www.novosoft.net/download/c2j.html]
c2j++: A C++ to Java translator based on c2j.
[http://members.aol.com/laffra/c2j.html]
Cubic Spline Library: A collection of C orutines that compute and manipulate cubic B-spline coefficinets under a variety of conditions. The routines handle two types of cubic splines, i.e. smoothing splines which fit the data in a least squares sense and interpolating splines which pass through specified points exactly. They also handle two types of boundary conditions, i.e. the natural spline where the curvature at the endpoints goes to zero and the periodic spline where the curve has the identical value, slope, and curvature at the endpoints. All routines are available in double and single precision, and some have Fortran callable interfaces. The CSL was created to provide a better method of searching astronomical photometric data for periodic behavior, and as such takes advantage of special B-spline features to perform a fast periodicity search.
The available CSL routines include those for computing:

B-spline function values,

Fourier integrals of spline curves,

constrained spline regression matrices,

spline curvature derivative matrices,

periodic smoothing splines,

B-spline polynomial and first and second derivative coefficients,

vector dot products,

spline curve Fourier series,

interpolating splines and inner products,

spline least square error matrices,

smoothing and periodic spline coefficients,

integrals of the square of spline curves,

periodic smoothing spline coefficients,

period-folded spline curves, and

spline curve values and slopes.

There are also routines for allocating and deallocating data structures, searching for optimum smoothing spline parameters, Gauss-Jordan matrix inversion, finding spline curve minima and maxima, solve real positive definite band matrix systems, performing fine gridded frequency searches, performing indexed heapsorts, and more.
A source code distribution of the CSL is available. All routines are written in ANSI C and are documented internally as well as in some external papers and reports. See Akerlof et al. (1994).
[http://www-personal.umich.edu/~akerlof/cubic-spline/ http://www-personal.umich.edu/~akerlof/cubic-spline/]
Cubpack++: A C++ package for two-dimensional cubature. This is TOMS algorithm 764 and is documented in Cools et al. (1997).
[http://www.acm.org/calgo/contents/]
[ftp://ftp.cs.kuleuven.ac.be/pub/NumAnal-ApplMath/Cubpack/]
CUMULVS: A software infrastructure for the development of collaborative environments which supports interactive visualization and remote computational steering of distributed applications by multiple collaborators. It also provides a mechanism for constructing fault-tolerant, migrating applications in heterogeneous computing environments. The features of CUMULVS include:

collaborative on-line visualization of remote simulations through multiple viewers connecting to a running application;

coordinated computational steering among several collaborators;

automatic recovery of the virtual environment to host or network failures;

fault-tolerance of distribution simulations via heterogeneous task migration and user-directed checkpointing;

a monitoring system fo high-performance scientific simulations;

dynamic viewer attachment and detachment;

message passing over wide-area ATM networks between multiple MPP and SMP systems; and

secure and authenticated data transfer.

CUMULVS contains a library for scientific applications that provides computational steering control and visual feedback that can be intuitively analyzed. This library can be integrated into applications written in either C or Fortran, with the applications requiring minimal modification to specify the nature and decomposition of the data fields to be analyzed and to define steering parameters. It can be used on top of any message passing system and with any front-end visualization system, with an example of the former being PVM and the latter Tcl/Tk. Extension to other message passing systems and/or front-ends is straightforward.
A source code distribution of CUMULVS is available. It is written in C and can be used on any platform that already supports PVM. A user's guide is available in PostScript format.
[http://www.epm.ornl.gov/cs/cumulvs.html]
CuPit: A programming language specifically designed to express neural network learning algorithms. It provides most of the flexibility of general-purpose languages like C, but results in much clearer and more elegant programs due to higher expressiveness, in particular for algorithms that change network topology dynamically (constructive algorithms, pruning algorithms). Furthermore, CuPit-2 programs can be compiled into efficient code for parallel machines; no changes are required in the source program.
CuPit language features include:

an object centered description of network topology,

special data types (e.g. CONNECTION, NODE, NETWORK),

parallel procedure calls,

automatic reductions,

winner-takes-all functions,

the dynamic creation/deletion of connections/nodes,

the capability to create network replicates and merge them into a single network,

PASCAL-like syntax (e.g. procedures, static typing),

access to external procedures/functions,

special I/O variables e.g. for I/O of example patterns, and

a complex interface for I/O of complete networks.

Compilers are available for sequential and symmetric multiprocessor (SMP) machines and they translate to C (with thread library calls for SMP). The library reads or writes networks as well as pattern files in SNNS formats.
The source code for the compiler is available and has been tested under Sun SunOS, DEC Alpha and Linux Intel platforms. It can be compiled using the ELI compiler construction system, installed as a binary for some platforms (of which one is not yet Linux), or compiled from the generated C source (from the ELI tools). Documentation is available in the form of a language reference and tutorial in PostScript format. A small collection of examples is also available.
[http://wwwipd.ira.uka.de/~hopp/cupit.html]
CUPS: The Common UNIX Printing System is a portable and extensible printing system for UNIX. The goals of this project and software are to:

provide standard support for text (US ASCII, UTF-8 and ISO-8859-x), PostScript, PDF, HP-GL/2, TIFF, JPEG, PNG, PBM, PGM, PPM, GIF, SGI RGB, Sun Raster and Kodak PhotoCD formats;

provide a standard command-line interface with a standard miminum set of options;

provide a standard API;

provide a common remote printing interface (IPP);

provide a printer browsing interface and allow access to remote printers via Internet addresses;

provide a scheduler extension interface to support interfaces separate from the printer driver (e.g. serial, parallel, lpd, TFTP, IPP, etc.); and

provide a standard interface for ACLs, quotas, accounting and logging.

The components of CUPS include:

a central print scheduling process (that is also an HTTP 1.1 server) that dispatches print jobs, processes administrative commands, provides printer status information to local and remote programs, and informs users when necessary;

a set of configuration files including HTTP server, printer and class definition, MIME type and conversion rules, and PostScript Printer Description (PPD) configuration files;

an Interface Library containing CUPS-specific convenience functions for queueing print jobs, access resources via HTTP and IPP, perform MIME typing and conversion, and manipulate PPD files;

various filters that support a common set of options;

backends for serial, parallel, lpd, TFTP, FTP, IPP, SMB and AppSocket connections (in version 1.0); and

System V and Berkeley command-line interfaces for submitting jobs and checking printer status.

Source and binary distributions are available, with one of the latter being for Linux platforms. This is available under the Aladdin Free Public License, which basically makes it free for most purposes other than commercial distribution.
[http://www.cups.org/]

CUPS-filters

A package for providing a generic filter to print from CUPS using Ghostscript.
[http://www.geocities.com/SiliconValley/8036/cups_page.html]
curl: A tool for automatically creating the links between the pages of a Web document. Curl uses the metaphor of a book to organize pages, with a typical situation having each page linked to its nearest siblings, its parent, and the top page of the document. Pages can contain two kinds of content lists and there are special pages for lists of links to keywords, figures, tables and new pages. There is also search engine available from every page. A source code distribution of curl is available.
[http://www.cs.mu.oz.au/~ad/curl/announce.html]
cURL: A program that gets files using HTTP, FTP, or Gopher protocols. The source code is available as are binaries for several platforms including Linux Intel. This used to be called HttpGet and UrlGet.
[http://curl.haxx.nu/libcurl/]
Curl: A language for creating web documents with nearly any type of content from formatted text to complex interactive applets. Curl provides a rich set of formatting operations similar to those implemented with HTML tags, although unlike HTML it can be extended by users to provide additional functionality ranging from simple macros to direct control over the positioning of subcomponnets. The Curl project is currently (10/97) developing several packages of useful formatting extensions. Interactive interfaces can be easily built using a Tk-like interface toolkit consisting of various interactive components. The Curl object-oriented programming language can be used to developed almost any sort of sophisticated mechanism in an interactive web document. The Curl expressions embedded in the document are securely compiled into native code by a built-in on-the-fly compiler and then executed without the need for an interpreter. The language features include multiple inheritance, extensible syntax, a strong type system, safe execution via encapsulation of user code, and extensive checking at both compile and run time. The Curl system and compiler are mostly written in Curl.
Binary versions of Curl are available for Sun SunOS, WIN32, and Linux Intel platforms. A source code distribution is also available. The documentation includes an online white paper and various documents contained within the distribution.
[http://cag-www.lcs.mit.edu/curl/]
CURSA: A Starlink Project package containing utilities for manipulating astronomical catalogues and similar tabular datasets. It provides facilities for browsing or examining catalogs, selecting subsets from a catalog, sorting catalogs, copying catalogs, and pairing two catalogs. CURSA can access catalogs in the FITS table format, the Small Text List (STL) format, or the CHI/HDS format used by the CATPAC catalog manipulating applications package. Allowable expressions for manipulating catalogs include arithmetic, relational, and boolean operators, bracketr, sexagisimal values (for degrees, hours, minutes, etc.), and great circle distances.
A binary version of the CURSA package is available for Linux Intel, DEC OSF/1, and Sun Solaris platforms. A 66 page user's manual is available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
curses: See ncurses.
CUTE: The Constrained and Unconstrained Testing Environment is a suite of Fortran subroutines, scripts and test problems for linear and nonlinear optimization problems. Its purpose is to provide a way to explore an extensive collection of problems (800 different test problems so far), a way to compare existing packages, a way to use a large test problem collection with new packages, motivation for building a meaningful set of interesting new problems, ways to manage and update the system efficiently, and to do all the above on a variety of platforms.
The CUTE package source code is available. It is written in Fortran 77 and single and double precision versions are available. Machine dependencies are carefully isolated and easily adaptable. There are standard installation scripts for many platforms and a Matlab version is available. There is as yet (3/97) no installation script for Linux platforms but it shouldn't be too tricky getting this going with the Linux/g77 combination. The documentation is contained within a user's guide available in PostScript format. See Bongartz et al. (1995).
[http://www.cse.clrc.ac.uk/Activity/CUTE]
CUTET: A Fortran implementation of an adaptive algorithm for computing an approximation to the integral of each element in a vector of functions over a 3-D region covered by simplices. A cubature formula of degree eight with 43 points is used to locally approximate an integral, and the local error estimate is based on the same evaluation points. The error estimation procedure tries to decide whether the approximation for each function has asymptotic behavior, and takes different actions depending on that decision. The simplex with the largest error is divided in eight simplices, and the local procedure is then applied to each new region, with the procedure repeated until convergence is reached. This is TOMS algorithm 720 and is documented in Berntsen et al. (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
CU30/qVIX: A real-time video codec (CU3) and video conferencing program (qVIX) for Linux. The codec is a better than realtime, no latency, full frame rate (30 FPS), high quality, low bandwidth algorithm designed for bandwidths of DSL and higher.
[http://cu30.sourceforge.net/]
cutils: A set of utilities for working with C code. The utilities are:

cinfo, for looking up the prototype of a standard C function in a database;

cinfoc, for compiling the database used by cinfo;

cinfodc, for decompiling a compiled database;

cdecl and cundecl, for decoding or encoding a complex type declaration;

cobfusc, converts a C source code file into a human unreadable yet compilable source code;

chilight, for highlighting source files with color escapes or commands;

ctangle and cweave, for producing a literate source document;

cunloop, obfuscates a source code by removing the loops and replacing them with goto instructions;

yyextract, for extracting the rules from a yacc grammar; and

yyref, a yacc cross-reference generator.

A source code distribution is available which is documented in a manual in Texinfo format.
[http://metalab.unc.edu/pub/Linux/devel/lang/c/]
CUTDSP: A package of C programs containing an implementation of a cutting plane approach based on semidefinite programming. CUTDSP currently implements max-cut, graph bisection and graph equipartition methods.
[http://www.imm.dtu.dk/~sk/cutsdp/]
CV: A toolset for the verification of VHDL descriptions using a formal technique called symbolic model checking. This makes it possible to completely and automatically verify properties of a design. The components of CV include:

cva, a standalone VHDL compiler that takes a VHDL description and produces VHDL library units in the working library;

cvc, the model checker which takes an input specification file, loads the corresponding VHDL library unit, and produces a yes or no answer;

libcv.a, a library defining the format of library units and functions;

several small VHDL examples and their specifications; and

documention in HTML and man page format.

A binary distribution is available for Linux and Solaris platforms.
[http://www.cs.cmu.edu/~cmuvhdl/]
CVAP: The Computational Vision and Active Perception Lab software is is a distribution of several C software packages which perform tasks specific to computer vision studies as well as more general tasks which underlie them.
The components of CVAP include:

Exception, an ANSI C exception system;

Opts, an advanced command line option parser which not only parses the command line but also converts the strings to C variable values;

Candela, an image processing system whose kernel contains data types representing 2-D imaes with integer or floating point pixels, image I/O, and utilities for printing information about the images;

Candisp, which provides support for displaying Candela images in various formats (e.g. PostScript, Abekas, TIFF, etc.);

Canapp is the Candela Application Library containing library functions and programs for image processing;

XOR++, an XOR (external object representation) interface to C++ which supports persistent objects in C++;

OPTIC, an Object Program Tools In C package which consists of macros which support classes, inheritance, and virtual functions in C as well as a C interface to XOR;

OPTICAL, an OPTIC Application Library containing a set of classes such as parameterized curves, polygons, points, and matrices as well as the Lux classes which provide an object oriented interface to Candela;

Sequences, a library and utilities to manage collections of data files;

Resedit, an interactive editor for Xt resources based on the GNU readline library; and

Image is a set of image display widgets and objects whose features include modularity and extensibility, support for overlays, and advanced color support.

Separate source code distributions of all of the CVAP packages are available, and some require others to work properly. They are all written in ANSI C and can be compiled and used on several types of UNIX platforms using the supplied configure script. Documentation for each package is contained in each package to a greater or lesser extent.
[http://www.bion.kth.se/software.html]
CVIPtools: The Computer Vision and Image Processing tools is a package for the exploration of computer vision and image processing. It is a collection of computer imaging tools that provide services at three layers:

a set of libraries (i.e. an API) at the lowest level;

the cviptcl and cvipwish shells which add image processing functionality to the Tcl/Tk package and its user shell; and

a GUI that allows the interactive experimentation with all of the functionality of the underlying tools.

The functionality available from the CVIPtools GUI includes:

edge/line detection and edge linking;

image segmentation;

morphological filters, e.g. gray-scale and color erosion, dilation, etc.;

2-D FFTs and related transforms;

frequency domain filters including highpass, lowpass, bandreject, etc.;

feature extraction, e.g. binary, RST-invariant, histogram, spectral and texture object features;

spatial domain image restoration via a wide range of filters;

frequency domain image restoration via a wide range of filters;

noise functions;

geometry transformations;

histogram-based image enhancement;

pseudo-color enhancement, e.g. frequency domain and gray level mapping;

spatial and frequency domain image smoothing and sharpening;

several image compression algorithms;

support for many common image formats;

image geometry operations, e.g. rotation, resizing, translation, etc.;

utilities for various arithmetic and logical operations, image file conversion, simple image creation, image enhancement, signal-to-noise ratio, adding noise, color space conversion, image object labeling, etc.;

on-line help pages; and

a built-in X11 image viewer.

Source and binary distributions of CVIPtools are available, with the latter including a Linux Intel version. Compilation from source requires Tcl/Tk. Documentation can be found in both Umbaugh (1998) or in a huge set of man pages.
[http://www.ee.siue.edu/CVIPtools/]
CViz: A visualization tool for clustering and analysis of multi-dimensional data sets. It is most readily applicable to data sets containing between 100 and 50,000 examples where each example has between 2 and 200 mostly numerical components (dimensions) each describing a different attribute of the data. Optionally, each example may be provided with a classification value, indicating what class it belongs to. Ideally, there should be between 2 and 20 different nominal classes in the entire data set. It is most valuable when applied to situations where little or no information is known about the relationships between attributes and class or between different attributes. CViz gives the data analyst a unique tool for viewing the entire set of data points across the most interesting dimensions in a short period.
CViz uses a k-means clustering algorithm to find interesting concepts in the data. It then draws 2-D scatter plots by selecting pairs or triples of concepts and relating these concepts to the data examples and the other concepts. By using an animation technique called touring, it allows the analyst to quickly cycle through all the different pairs or triples of concepts and see how the data changes from one perspective to another. This can often provide a unique insight into underlying structure of the data. A source code distribution of CViz is available. It is written in Java.
[http://www.alphaWorks.ibm.com/formula/CViz]
CVM: The Coherent Virtual Machine is a distributed shared memory (DSM) system. A very early release of the software is available (4/97) although this is an ongoing project. The goals of CVM include:

multiple protocol support with the initial configuration file providing four memory models, i.e. single- and multiple-writer versions of lazy release consistency,

sequential consistency, and eager release consistency;

extensibility in that the source will be freely available and the modules are written in C++;

multi-threading support which will allow overlap of computation and communication through context switching; and

fault tolerance sufficient to allow the system to recover from at least one node failure at a time.

[http://www.cs.umd.edu/projects/cvm/]
Cvo: C++ Visual Objects is a toolkit for the building of visual tools for the X Window system. It is written in C++ and visually resembles the Motif toolkit but there are significant differences between Cvo and other toolkits. These differences or features include an object oriented design, executables typically 2 to 4 times smaller than those compiled using other tookits, less code to write per application, a smaller and more consistent set of interfaces, and applications that are (due to the above reasons) inherently more maintainable. Another major feature of Cvo is that it takes advantage of the internationalization features inherent in X11R5 and later releases.
A rich set of visual objects is provided, including the standard things like buttons, text displays, input boxes, pop-up and pull-down menus, scrolling lists, and radio boxes. More specialized objects such as a chart object that expands to support 3-D and pie charts and a canvas on which an application may paint are also included. New complex objects may be easily constructed using existing objects as bulding blocks due to the object oriented nature of the toolkit. Cvo also attempts to consolidate similar concepts within a single method, e.g. "callback" functions are treated like any other "event" which reduces not only the complexity of the system but also the amount of information an application writer needs to remember to use it.
Cvo was created as an internal Cray Research Inc. project but, due to various reasons unrelated to its utility, made freely available subject to a fairly permissive copyright notice. Extensive documention is included with the distribution including a tutorial in PostScript and hypertext documentation of the visual objects in the toolkit. There are several makefiles for various architectures and Cvo will build using GCC/G++, making it amenable for compilation and use on Linux platforms
[ftp://ftp.x.org/contrib/libraries/]
CVS: A version control system which can record the history of a set of source files. CVS keeps track of old versions of files in an efficient manner by storing only the differences between successive versions. It also allows groups of people working on the same file to separately make changes, merging all the changes only when each developer is done. It keeps track of revisions by giving each file in the revision tree a unique revision number, and allows revision trees to be split into separate branches with each a self-maintained line of development that can be easily merged back into the main trunk. All files and directories under version control are stored in a repository which is almost always accessed via CVS commands rather than directly. CVS is a complex program with many features and capabilities.
A source code distribution of CVS is available. It is written in C and can be compiled and used on many types of platforms using the configure script supplied in the distribution. It is documented in a 120 page user's manual available in Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://www.cyclic.com/]

Cervisia

A graphical front-end to CVS that provides access to most of its features.
[http://cervisia.sourceforge.net/]

CurVeS

A visual interface for the CVS version control system. CurVeS provides two major functions. It provides a menu and a command completion interface to CVS for inexperienced users which also includes several meta-commands built from basic CVS commands which are used together in common use circumstances. It also provides a visual representation of a project directory so the status of each file can be seen at a glance. It uses color to accent the file classification marks. A source code distribution of CurVeS is available. It was designed and built on a Linux Intel platform.
[ftp://ftp.buici.com/pub/curves/]
[http://www.han.de/~racke/pard/version_control.html]

CVS Build System

A set of Perl scripts that provide extra functionality to the basic CVS system. These enhancements include:

utilities to simplify the creation of initial modules and module tagging;

configuration management for groups of modules called products;

utilities to automate checking out, branching and merging of products in one operation; and

an integrated build system for products.

[http://www.fsj.co.jp/fsj/developers/cvsbs.htm]

cvs-track

A set of Bourne shell scripts that act as wrappers to CVS for the purpose of making the act of tracking vendor sources easier, i.e. to ease importing and merging onto the main development branch. The components are:

track, the main program;

cvs-cmp, a helper program for track that comparies a working directory to a repository; and

cvs-move, which allows you to move CVS-controlled files in a couple of ways.

[http://www.paranoia.com/~vax/cvs-track/cvs-track.html]

CVS Web

A utility to create and browse CVS trees via the Web.
[http://www.freebsd.org/~fenner/cvsweb/]
[http://linux.fh-heilbronn.de/~zeller/cgi/cvsweb.cgi/]

cvslines

A package that extends CVS to provide extra support for managing multiple concurrent lines of development. Cvslines is a set of wrappers that help with merging changes between CVS branches, i.e. different lines of development. It takes the approach that it is preferable to perform such merges on a file-by-file basis at the time the changes are checked into a line of development. It doesn't do anything that can't be done with existing CVS commands but is helpful in that it:

helps solve the ``you must remember to do it'' problem by forcing the issue;

promotes doing the merge now rather than putting it off;

guides a user through the correct sequence of CVS commands needed to merge changes from one development line to another; and

helps to eliminate the creation of unneeded RCS branches until they're needed.

A source code distribution of cvslines is available. It is written in C and documented in a man page.
[http://www.netapp.com/technology/freeware/cvslines/]
[http://www.FreeBSD.org/~jkoshy/PORTS/]

cvs2html

A Perl program that transform CVS log output files into HTML.
[http://www.sslug.dk/cvs2html/]

gCVS

A portable GUI for non-technical users of CVS. It was written specifically for managing HTML and other non-source documents in the context of Web projects, but can be useful for all CVS applications. The basic mode of operation is to drag and drop files onto the application and then choose and operation to perform on those files. The available commands include edit, unedit, add, remove, commit, release, update, import, checkout, login and quit.
A source code distribution of gCVS is available as are binaries for several platforms including Linux Intel. Documentation is a bit sketchy and contained in a README file included in the distributions.
[http://dsg.harvard.edu/public/software/gcvs/]

tkCVS

A Tk-based graphical interface to the CVS configuration management system. It includes facilities for providing user-friendly names to modules and directories within a depository as well as a facility to interactively browse the repository. The features include:

a file and directory browser with optional display of hidden files and display of the current directory's location within the CVS tree;

pushbutton-based check-in and check-out of CVS modules with the ability to add and delete files using pushbuttons;

a module tree browser and reports showing the structure of the CVS modules tree;

updating of files from the repository when they change;

tagging and branching of files from the file browser;

tagging and branching of modules from the module browser;

exporting a CVS module or directory from the respository for delivery offsite;

creation of patch files between two releases of a module or between a release and the current version; and

viewing of diff and status listing for currently checked out modules.

A source code distribution of tkCVS is available. It supports CVS versions before 1.3 but 1.6 is recommended. The most recent release also requires Tk version 4.0.
[http://www.NeoSoft.com/tcl/ftparchive/sorted/apps/tkcvs-6.0/]
CVSup: A package for distributing and updating collections of files across networks. CVSup can efficiently and accurately mirror all types of files including sources, binaries, hard links, symbolic links and device nodes. It uses a streaming communication protocol and multiple threads to provide one of the fastest general purpose mirroring tools available. CVSup also includes special features and optimizations specifically tailored to sf CVS repositories including:

extraction of new deltas directly from the RCS files on a server and editing them directly into the client's RCS files;

noting the addition of new symbolic tags to files on a server and sending only the new tags to the clients;

merging new deltas and tags from the server with deltas and tags added locally on client machines; and

distribution of specific checked-out versions.

A source code distribution of CVSup is available under a BSD-style license. Binaries are also available for a wide range of platforms. This uses both rsync and zlib for appropriate tasks.
[http://www.polstra.com/projects/freeware/CVSup/]
CWB: The Edinburgh Concurrency WorkBench is an automated tool for the manipulation and analysis of concurrent systems. It allows for various equivalences, preorder and modeling checking using a variety of different process semantics. The functionality includes:

defining behaviors given either in the syntax of the Temporal CCS (TCCS) or SCCS and perform various analyses of these behaviors, e.g. analyzing the state space of a given process or checking various semantic equivalences and preorders;

defining propositions in a powerful modal logic and checking whether a given process satisfies a specification formulated in this logic;

deriving automatically logical formulas to distinguish nonequivalent processes; and

interactively simulating the behavior of an agent, guiding it through its state space in a controlled fashion.

A source code distribution of CWB is available. It is written in ML and requires the SML/NJ v0.93 compiler for compilation and use. A user's manual is available in PostScript format.
[http://www.dcs.ed.ac.uk/home/cwb/]
CWEB: A software system that facilitates the creation of readable programs, i.e. a literate programming system. WEB was originally developed by Donald Knuth as he wrote the TeX typesetting system. The use of WEB allows users to write programs of superior quality, produce state-of-the-art documentation, greatly reduce debugging time, and easily maintain programs as conditions change. A CWEB source file contains text and commands that allow it to be processed to obtain either a program in one of several programming languages or the documentation for that program in TeX format. CWEB is a version of WEB for documenting C, C++, and Java programs. The CWEB program is fully documented in Knuth (1993a) and is freely available at the given URL. The software consists of two programs: CTANGLE, which converts a source file to a compilable program source code file; and CWEAVE, which converts a source file to a TeX source code document. See also Knuth (1992) and Levy and Knuth (1994).
[ftp://labrea.stanford.edu/pub/cweb/]
CWEBx: A modified implementation of the CWEB literate programming system for the ANSI C language and plain TeX output. CWEBx has a full compatibility mode with CWEB as well as some extensions including typedef declarations that globally affect formatting in the source file, scanning of include files for typedef definitions, flexible selection of layout style, referring to sections using symbolic labels, a new and modular set of grammar rules based on ANSI C syntax, and a new manual.
[http://wallis.univ-poitiers.fr/~maavl/CWEBx/]
CwMtx: The Cooperware matrix library is a C++ library that provides classes for performing matrix and vector operations commonly used in science and engineering. A special features is a class implementing quaternion math. This is available under the LPGL.
[http://www.xs4all.nl/~hkuiper/cwmtx.html]
CWP/SU: This description has been moved to SU.
cxref: A program which inputs a series of C source files and outputs a LaTeX or HTML document containing a cross reference of the files, functions, and variables in the program, including documentation taken from suitably formatted comments in the source code. The documentation is stored within the C source code in a specially formatted comments. The cross referencing includes lists of functions called, callers of each function, usage of global variables, header file inclusion, macro definitions, and type definitions. The works with ANSI C including many gcc extensions.
[http://www.gedanken.demon.co.uk/cxref/]
C-XSC++: A C++ class library for eXtended Scientific Computing. This is an update and extension of the C-XSC library for the development of numerical algorithms that deliver highly accurate and automatically verified results. C-XSC provides an interface between scientific computing and the C/C++ languages via abstract data structures, predefined operators and functions. It also supports the programming of algorithms that automatically enclose the solution of a given math problem in verified bounds.
The key features of C-XSC include:

real, complex, interval and complex interval arithmetic with mathematically defined properties;

dynamic vectors and matrices;

subarrays of vectors and matrices;

dotprecision data types;

predefined arithmetic operators with high accuracy;

standard function with high accuracy;

dynamic multiple precision arithmetic and standard functions;

rounding control for I/O data;

error handling; and

a library of problem solving routines.

This is being developed with an requires post-EGCS versions of the GCC compiler.
[http://www.uni-karlsruhe.de/~uad3/cxsc/]
[http://www.xsc.de/XSCinfo/xscinfo.html]
CXX: A set of C++ utilities to make it easier to extend Python with C++. CXX integrates C++ with Python by:

using C++ exception handling to detect errors and clean up, i.e. keep track of what objects need to be dereferenced when an error occurs;

allowing the STL and its algorithms plug and play with Python containers such as lists and tuples; and

offering an extensions facility that allows replacing C tables with objects and method calls that define modules and extension objects.

[http://cxx.sourceforge.net/]
CybOrg: The Cybersource Office Organizer is a project intended to developed a modular and flexible office management application suite. This is being developed on top of PHP, MySQL and PostgreSQL. A source code distribution is available under the GPL.
[http://www.cyber.com.au/cyber/product/cyborg/]
cygwin: A project to create ports of the GNU development tools to Windows for x86 and PowerPC processors. The applications built with these tools will have access to the Microsoft Win32 API and the Cygwin32 API (which provides additional UNIX-like functionality, e.g. sockets, process control, etc.). A cygwin installation enables users to:

write Win32 console or GUI applications which make use of the two APIs previously mentioned,

configure and build many GNU tools from source (including the cygwin tools themselves under x86 NT),

port other UNIX programs to Windows NT/95 without having to make significant source code changes, and

work in a reasonably full UNIX-like environment with access to many common UNIX utilities.

This port was accomplished by first modifying the GNU development tools to enable them to generate and interpret Win32 native object files. The next step of porting the tools to Windows NT/95 was accomplished by writing a shared library called cygwin.dll which adds the needed UNIX-like functionality to the Win32 API. The new interface, called Cygwin32, made it possible to build working Win32 tools by using UNIX-hosted cross-compilers and linking against the library. Finally, native tools capable of rebuilding themselves under Windows NT/95 were produced by modifying configure scripts and making minor source code changes.
The cygwin package is available in both source and binary versions, although a binary version has to be installed before the source version can be compiled. Separate binary versions are available for the full development toolkit and for a subset of this which includes popular user tools, e.g. bash, etc. The standard GNU documentation for the separate development and user tools also applies to this port.
[http://sourceware.cygnus.com/cygwin/]
CynLib: A hardware description library (HDL) written in C++. This is a complete enviroment for designing electronic hardware including simulation, debugging and synthesis capabilities. This class library implements many of the semantic features found in Verilog. CynLib provides a standard, supported mechanism for regularizing the electronic design process. It also provides a framework for the successive elaboration of a design into a form that can be used by standard design tools, allowing a model to be translated into implementable hardware in a series of small refinements rather than in one large step. The final RTL (run-time library) Cynlib design can be translated into either Verilog or VHDL RTL.
The Cynlib class library consists of a set of header files and a library file. Hardware model sources are linked to these and compiled to obtain an executable. The features of the library include:

support for only two-state data values to increase simulation speed;

the concept of hardware modules to allow systems to be developed in a hierarchical manner;

a special class for clock-driven events to allow hardware modeling in a cycle-based paradigm;

support for an arbitrary number of clock signals for simulation events;

deferred or non-blocking assignments for several data types for describing synchronous systems;

threads implementing processes that wait an integral number of clock cycles during their execution; and

several features that support debugging.

A source code distribution of CynLib is available under an Open Source agreement modeled on the MPL. It can be compiled using recent versions of the GNU compiler suite. Documentation includes user's and reference guides in PDF format.
[http://www.c2da.com/cynopen/]
[http://www.cynapps.com/]

[ home / linux ]

Next: Da-Dm Up: Linux Software Encyclopedia Previous: Ca-Cm Contents

Manbreaker Crag 2001-03-08