Next: Bibliography 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 .
[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/]
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/]
[http://web.tiscali.it/albertosantini/cobcy/]
COBOL: A language making a big comeback due to the Year 2000 software problem. Freely available compilers are:

Cobcy and

Deskware COBOL.

[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.cs.tum.edu/Par/tools/Projects.Old/CoCheck.html]
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://cocom.sourceforge.net/]
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.
[http://www.zib.de/SciSoft/CodeLib/]
[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.newplanetsoftware.com/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.coin3d.org/]
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;

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

IPOPT, an interior point algorithm for general large-scale nonlinear optimization;

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.ipv4.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.sourceforge.net/]
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.sourceforge.net/]
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 .
[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 and .
[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 .
[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 , , , , , , , , , , , , , , , , , , , and .
[http://www.apl.jhu.edu/~hall/lisp.html]
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.

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: 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,

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.math.princeton.edu/tsp/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://www.ohse.de/uwe/software/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]
[http://www.zcu.cz/ftp/pub/network/mbone/mmrz/confman/]
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 .
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]