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/]
[htt