Next: Cn-Cz Up: Linux Software Encyclopedia Previous: Bn-Bz Contents

Ca-Cm

Last checked or modified: Mar. 6, 1999

C: C is second only to Fortran in the amount of code for numerical and scientific applications that's available. On Linux boxes the C language and the GNU C compiler (GCC) are inextricably linked.
Resources with information about C include:

Linux GCC FAQ
[ftp://www.mrc-apu.cam.ac.uk/pub/linux/GCC-FAQ.html]

comp.lang.c FAQ
[http://www.eskimo.com/~scs/C-faq/top.html]

C Programming Reference
[http://www.gator.net/~garyg/C/cref.html]

Lysator C Archive
[http://www.lysator.liu.se/c/]

SNIPPETS Collection
[http://www.snippets.org/]

CScene
[http://www.syclus.com/cscene/]

Some popular and useful textbooks which either cover the basic language or its use for performing numerical tasks are Brooks (1999), Darwin (1988), Harbison and Steele (1995), Horton (1990), Kernighan and Plauger (1978), Kernighan and Ritchie (1978), Kernighan and Ritchie (1988), Kochan and Wood (1991), Koenig (1989), Libes (1993), Oualline (1993), Plauger (1992), Plauger and Brodie (1996), Plum (1989), Press et al. (1994a), Rojiani (1996), Schumacher (1994), Sedgewick (1990), Shammas (1995), Straker (1994) and Summit (1995).
Freely available C compilers, interpreters and other programs that facilitate better C programming and programs include:

CINT, a C/C++ interpreter;

C-Mix, an automatic partial evaluator for the ISO/ANSI C language;

DJGPP, a 32-bit C/C++ development system (based on the GNU utilities) for x86-based machines running DOS;

egcs, an experimental compiler for integrating variations to and patches for GCC;

EiC, a recursive-descent C interpreter;

GCC, the GNU compiler; and

lcc, a retargetable compiler for C.

Related source code preprocessors and/or checkers include:

bcc, a set of patches for GCC that implement bounds checking;

cPost, generates a PostScript file from a set of C source code files;

cproto, generates C function prototypes and converts function definitions;

C-Refine, a preprocessor that adds a language construct called refinement;

cscope, a tool for browsing program code;

cutils, a set of utilities for working with C source code;

cxref, a program that can automatically generate documentation and cross references for a C program;

dcc, a checker that performs full syntactic and some static semantic analysis of a C program;

Enquire, a program that determines the properties of a C compiler and the machine on which it runs;

erltools, a prettyprinter, a lexical parser generator and a syntactic tree manipulation tool;

isomac, a program that attempts to find illegal macros in system header files;

LCLint, a tool for statically checking C programs;

liwc, a collection of programs to manipulate C source code;

Metre, an ANSI/ISO standard C parser;

mpr, a memory profiling package for detecting leaks and compiling statistics about memory allocation;

Porch, a source-to-source compiler that translates C programs into those capable of svaing and recovering from portable checkpoints; and

publib, a library of C functions and a framework for building such a library from components.
C++: A bloody huge and popular language that is coming into its own as a language for numerical computations in the 1990s. Compilers, preprocessors and related packages include:

CINT, a C/C++ interpreter;

Frost, a compiler wrapper for allowing the use of multi-methods and virtual function arguments; and

GCC, the GNU compiler system which features a C++ backend.

Interesting and useful information sources include:

WWW C++ Information
[http://www.kfa-juelich.de/zam/cxx/extern.html]

Quadralay's C++ Archive
[http://www.austinlinks.com/CPlusPlus/]

Jon's C++ Resources Directory
[http://www.cs.bham.ac.uk/~jdm/cpp.html]

G++ FAQ
[http://www.cygnus.com/misc/g++FAQ_toc.html]

C++ Standard Library
[http://www.dinkumware.com/htm_cpl/index.html]

CScene
[http://www.syclus.com/cscene/]

C++ Programming for Scientists
[http://math.nist.gov/pozo/c++class/]

Object Oriented Numerics Page
[http://monet.uwaterloo.ca/blitz/oon.html]

Texts covering the application of C++ to scientific computing or object-oriented numerics include Barton and Nackman (1994), Dubois (1996), Shammas (1995), and Buzzi-Ferraris (1993). Also interesting are the series of papers Haney (1994), Robison (1996), Haney (1996), and Furnish (1997) detailing the progressive modifications of C++ to make it a better tool for scientific computation. Textbooks which cover the basic language or advanced features include Ellis and Stroustrup (1990), Koenig (1996), Langer and Kreft (2000), Lippman (1989). Lippman (1997), Oualline (1995), Plauger (1995), Satir and Brown (1995), Sedgewick (1992), Stroustrup (1991), Stroustrup (1994), Sutter (2000) and Weiss (2000).
The C++ libraries pertaining to numerical analysis tasks such as linear algebra and the solution of differential equations include:

Adlib, a C++ library implementing a runtime kernel for manipulating HPF-style regular distributed arrays;

ADOL-C, for the evaluation of arbitrary order derivatives of functions;

AmrPoisson, for solving Poisson's equation using multigrid and adaptive mesh refinement;

A++/P++, array classes for numerical computations with structured grids;

ARPACK++, for solving large scale eigenvalue problems;

Blitz++, an experimental numerical library attempting to equal the best Fortran codes in performance;

Boxlib, for developing box-structured finite difference programs in fluid dynamics and related areas;

BPKIT, a toolkit of block preconditioners for the iterative solution of linear systems;

CODE++, for solving ODEs;

CwMtx, a C++ library for common vector and matrix operations including a class implementing quaternion math;

Diffpack, for the numerical solution of PDEs;

FFTPACK++, a wrapper for the routines in FFTPACK;

FXT, an FFT library;

GNUSSL, a scientific subroutine library;

Godess, for building differential equation solvers;

GRUUMP, for manipulating unstructured finite element meshes;

HCL, for implementing mathematical objects such as vectors and linear operators;

IML++, iterative methods for solving symmetric and nonsymmetric linear equation systems;

ISIS++, an object-oriented framework for solving sparse systems of linear equations;

KASKADE, for solving linear scalar elliptic and parabolic problems in up to 3-D using finite element methods;

LAPACK++, for numerical linear algebra;

LightMat, for efficient arithmetic and basic math functions on vectors and matrices;

LinAlg, for linear algebra;

MatClass, for numerical computations;

MOUSE, a C++ library for finite volume computations on unstructured grids;

MTL, a high performance linear algebra library;

MV++, for high performance numerical computing;

NAO, a library for creating software for numerical simulations;

Newmat, a library for matrix operations;

ODE++, for solving ODEs;

Overture, for writing programs to solve PDEs;

PETSc, a portable, extensible toolkit for scientific computations;

POOMA, an object-oriented framework for developing parallel applications;

ROOT, for building large-scale data analysis applications;

Scientific Math Library, for a wide range of mathematical applications;

sl++, a scientific library project;

SparseLib++, for sparse linear algebra computations;

Template Numerical Toolkit, for numerical computation tasks; and

TIDE, for numerical computations with DEs.

The other C++ libraries contained within this compilation include:

ACE, a toolkit implementing fundamental design patterns for concurrent communication software;

ACS, a project to develop a core class extensible C++ to implement a commercial quality multi-line communications server;

Adsmith, a library implementing a distributed shared memory system on top of PVM;

AIPS++, for astronomical data post-processing including calibration, editing, image manipulation and analysis;

AISearch, for developing problem solving software;

Amulet, a user interface development enviroment;

Arjuna, tools for the development of fault-tolerant distributed applications;

ASN-EZE, an ASN.1 to C++ compiler and library that implements the X.208 and X.209 ASN.1 syntax and encoding rules;

BasicTools, a C++ library for simplifying the development of C++ software;

Cgicc, for creating CGI applications;

CGI++, a tool for writing CGI/database applications in C++;

Chaos Classes, for the study of dynamical systems;

CLN, a class library for numbers;

c++advio, for the variable-bit coding of sequences of integers;

C++SIM, a discrete event process-based simulation package;

C4, for parallel programming via high-level abstractions;

CNCL, generic classes plus a simulation library capabilities in random number generation, statistics, and event-driven simulation;

CONICAL, for simulations in computational neuroscience;

COOOL, for solving optimization problems;

Coral Tree Library Set, a collection of libraries that provide a system-independent set of services and functionality;

CppIma, for image processing;

cppp, a C++ parsing and semantic analysis program and library;

Crypto++, a library of cryptographic primitives;

CVM, for implementing distributed shared memory systems;

Cvo, for building visual tools;

DEMOCRITOS, for supporting tasks in bioinformatics and computational chemistry;

DmPack2, basic and varied container classes;

Dome, distributed objects for parallel programming;

DOME, for implementing distributed systems using the CORBA architecture;

doubledouble, for implementing doubled-double precision floating point arithmetic;

Drat, an interface to Ncurses;

DSC, for the distributed processing of coarse grained computations;

DS++, a variety of data structures making significant use of templates;

EasySQL, a database independent C/C++ SQL interface library;

EcoSim, for individual-oriented discrete event simulation and ecology;

ELROS, for the distribution of scientific applications across multiple platforms;

Evolvuton, for creating software and entities that can behave in an intelligent manner;

EvoX, for the simulation of complex systems;

Festival, a multi-lingual speech synthesis system;

FFC, to aid in the construction of safe Internet clients, servers and firewalls;

ffGraph, for creating, manipulating and displaying directed graphs;

FIRE, a C++ class library implementing finite automata and regular expression algorithms;

fltk, a GUI toolkit;

GAGS, for creating genetic algorithms;

GAlib, for creating genetic algorithms;

Gambit, for building, analyzing and solving n-person games;

GAMMA, for developing magnetic resonance programs;

GINA++, for developing GUIs;

GiST, for implementing generalized search tree database indexing schemes;

GLP, which converts OpenGL to PostScript;

gltt, for accessing TrueType fonts from OpenGL;

GOOD, for building interactive 3-D applications;

GPC++, for genetic programming;

GPK, for genetic programming;

Grafix, for developing GUIs to visualize the results of scientific computations;a

Graphlet, for implementing graph editors and graph drawing algorithms;

Graph3D, for implementing a real-time 3-D rendering library;

Gt, for creating GUIs;

GTK-, a wrapper for GTK;

GTL, a graph library based on STL;

Hush, an interface to Tcl/Tk;

Icnet, for creating client/server applications on the Internet;

image, for manipulating grayscale images;

ImageLib, a C++ library for image processing;

InterViews, for building GUIs;

Isearch, a text searching system;

IUE, for performing research in image understanding;

ivtools, for building custom drawing editors and servers;

KeLP, for implementing portable scientific applications on distributed memory parallel computers;

LEDA, data types and algorithms for combinatorial computing;

libcab, for creating, using and modifying cabinet files;

libcgi++, for CGI programming;

Libsigc++, a framework implementing a full callback system;

libsql++, a library that wraps ODBC calls into an object-oriented interface;

LiDIA, for computational number theory;

LInteger,

LPARX, for parallel calculations on MIMD machines;

magnum, which implements fast factorization algorithms for univariate polynomials over finite fields;

MAM/VRS, a toolkit for animated, interactive 3-D graphics;

MAPC, for manipulating algebraically defined points and curves in the plane;

MET++, a framework for developing multimedia applications;

MIME++, for dealing with MIME documents;

MME, for creating multimedia applications and user interfaces;

MOOSE, for discrete event and continuous simulations;

MPI++, a wrapper for MPI;

MPI-2 C++, a wrapper for MPI-2;

MPQC, for quantum chemistry calculations;

MTL, for developing common communications protocol applications;

Newmat, for matrix computations;

Nexus, for multithreading, communication and resource management facilities;

NTL, for integer and real arithmetic;

Octave, for numerical analysis;

OOMMF, a micromagnetic code project;

OPP, for cross-platform development amongst other things;

OSE, a collection of programming tools and class libraries;

paintlib, for image file decoding and manipulation;

PANDA, for data management in I/O intensive high performance applications;

Para++, for constructing message passing applications;

PAWS, for linking together the data structures of separate parallel applications;

PPI++, an object-oriented message passing library;

Qt, for building GUI applications;

QpThread, a thread library written in C++ that provides an object-oriented framework on top of system level threads;

QvLib, for parsing VRML files;

RAY++, classes for ray tracing;

RT++, for providing higher-order threads;

sC++, for enhancing C++ with active objects and synchronization primitives;

SDTS++, for applications that can read and write SDTS datasets;

SESAME, for prototyping and implementing various types of nets, e.g. neural nets;

SFL, a portable function library with nearly 250 various types of functions;

Shadows, for distributed programming;

SIMEX, for building discrete-event micropopulation models;

SimPack, for implementing discrete event, continuous and combined simulation models;

SOLID, for collision detection of 3-D objects undergoing rigid motion and deformation;

SoPlex, for solving linear programming problems with primal and dual simplex algorithms;

SPKit, for audio signal processing;

STK, for audio signal processing and music synthesis;

STL, a set of easily composable container classes and generic algorithms;

SWiFT, a feedback toolkit for building adaptive and predictable systems;

TAGL, a subset of OpenGL;

TOLKIEN, for implementing genetic algorithms and classifier systems;

TOOPS, for the process-oriented simulation of communications protocols;

TPIE, for the transparent use of parallel disks in applications involving gigabytes of data;

V, a GUI application development framework;

VarDen, for simulating the incompressible Navier-Stokes equations on rectangular grids;

VerGO, for optimizing twice continuously differentiable functions of any number of variables;

ViewKit, for developing Motif applications;

VLE, wrapper classes for the OpenGL, Mesa and CosmoGL libraries;

Vtk, for 3-D graphics and visualization;

WAILI, a wave transform library;

wxWindows, for cross-platform GUIs;

Xbase, for manipulating Xbase datafiles;

xclass, a GUI toolkit with the look and feel on Windoze 95;

Xclasses, for building GUI applications;

XForms, a GUI toolkit;

Xm++, for developing multiplatform and client/server GUIs;

XMU, a C++ library for geometric algebra, tensors, matrices and utilities;

XPCE, a symbolic object-oriented GUI toolkit;

Xterminal, for creating text-based user interfaces;

YACL, for common programming tasks; and

Zombie, for applications involving stream-type connections among several clients.

[http://www.kfa-juelich.de/zam/cxx/extern.html]
c++advio: A C++ class library containing code that performs:

a variable-bit coding of sequences of integers (including arithmetic compression),

the trick of sharing a stream buffer among several streams,

handling of extended file names, and

explicit endian specification in dealing with integer streams.

It also includes a Vocabulary package containing (poly/homo)morphic dictionaries with a dynamic inheritance path as well as a few convenience functions and classes. A source code distribution is available which has been compiled using gcc 2.7.2. Documentation includes a README file and comments within the code itself.
[http://www.lh.com/oleg/ftp/packages.html]
C++//: The C++ parallel language was designed and implemented with the aim of importing reusability into parallel and concurrent programming in the framework of the MIMD model. It defines a comprehensive and versatile set of libraries using a small set of simple primitives without extending the syntax of C++. The characteristics of the programming model include:

processes are active objects, sequential and single threaded;

communications with active objects are syntactically programmed as member functin calls and are asynchronous;

an object is automatically blocked when it attempts to use the result of a member function call that has not yet been returned;

there are no shared passive objects; and

passive object parameters are passed by value.

A source code distribution is available which requires a C++ compiler and PVM 3.3.7 or greater to compile and use. This has been successfully used on Linux platforms.
[http://www-sop.inria.fr/sloop/c++ll/index.html]
C++SIM: An object-oriented simulation package written in C++. It provides discrete event process-based simulation similar to SIMULA's simulation class and libraries. The capabilities include SIMULA-like simulation routines, random number generators, queueing algorithsm, and thread package interfaces, entity and set manipulation facilities similar to SIMSET, classes that allow non-causal events to be handled, various statistical gather routines, and debugging classes. This package will work on Sun, HP and Linux platforms with the supported thread package for the latter being the GNU Rex lightweight processes library. Documentation includes manual pages and a user's guide See Little and McCue (1993).
[http://cxxsim.ncl.ac.uk/]
CACAO: A 64-bit just-in-time (JIT) compiler for Java which translates Java byte code on demand into native code for the Alpha processor. The stack-oriented Java byte code is transformed into register-oriented intermediate code with local variables and stack locations replaced by pseudo registers to eliminate the 32-bit restriction on address types. A fast register allocation algorithm is then used to map the pseudo registers to machine registers. CACAO is up to 85 times faster than the JDK interpreter and 7 times faster than the Kaffe compiler, although it is slightly slower than equivalent programs written in C.
Binary versions of CACAO are available for Linux Alpha and Digital UNIX platforms. It can be used with the class library of JDK 1.0.2, although it does not support AWT. Work is underway to integrate this with the BISS-AWT library. This is currently documented in a man page and in various pages online at the site.
[http://www.complang.tuwien.ac.at/java/cacao/]
Cactus: A modular portable and manageable environment for collaboratively developing high-performance multidimensional numerical simulations. The features of Cactus include:

a powerful API with user modules (thorns) that plug into a compact core (flesh) as well as configurable interfaces, schedules and parameters;

MPI-based parallelism for finite difference grids;

access to a variety of supercomputing architectures including clusters;

several parallel I/O layers;

fixed and adaptive mesh refinement;

elliptic solvers;

tools for metacomputing, distributed computing and visualization;

collaborative development features for sharing the code base;

TestSuite code checking technology; and

an extensive suite of numerical relativity and astrophysics applications.

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

csed, a full-featured 2-D structure editor with many advanced features;

csbr, a 2-D structure browser;

csir, a spectra display program for JCAMP files;

csxy, an X-Y data plotter;

cswa, a WWW Chemical MIME access tool;

csimg, a chemical GIF image viewer and generator;

csws, a networked WWW substructure search tool;

csnmr, a networked NMR shift archive access tool;

cssharc, an ab initio archive access client;

and much more.
The binary server distribution is available for several platforms including SGI IRIX, Sun SunOS, and Linux Intel. The rest of the tools are all written in standard Tcl/Tk for which a distribution is included in each package. There is currently (6/97) a manual for the structure editor but not much documentation for the other programs.
[http://www2.ccc.uni-erlangen.de/software/cactvs/]
CADP: The CAESAR/ALDEBARAN Development Package is a software engineering toolbox for protocols and distributed systems that offers a rich variety of functionality from interactive simulation to the most recent format verification techniques. Some unique features offered by CADP include:

several input languages including process algebra with values, finite state machines, and networks of communicating finite state machines;

two different tools for computing bisimulations;

two different model-checkers for various temporal logic and mu-calculus variations; and

several verification algorithms including exhaustive LTS generation, on-the-fly verification, symbolic verification using Binary Decision Diagrams, and compositional verification based on refinement.

The CADP toolbox contains several closely interconnected components including:

ALDEBARAN, a tool for verifying communicating systems represented by labelled transition systems (LTS);

CAESAR, a compiler that translates the behavioral part of a LOTOS specification into either a C program or into an LTS;

CAESAR.ADT, a compiler that translates the data part of LOTOS specifications into libraries of C types and functions;

CAESAR.INDENT, a LOTOS program syntax checker and formatter;

OPEN/CAESAR, an extensible, language-independent environment for the development of user-defined programs for simulation, execution, verification, and test generation;

BCG, a format for the representation of explicit LTSs and a collection of libraries and programs for dealing with the format;

XTL, a functional-like programming language designed to allow an easy, compact implementation of various temporal logic operators;

EUCALYPTUS, a GUI written in Tcl/Tk that integrates CADP and several other tools in a unified interface; and

INSTALLATOR, the CADP installation assistant.

There are also plugins for several other related software packages that can then be accessed through EUCALYPTUS.
Binary versions of the CADP suite are available for several platforms including Linux Intel. It is distributed free of charge to universities and academic research centers after a license agreement is obtained, completed and returned. Vast amounts of documentation are available at the site.
[http://www.inrialpes.fr/vasy/pub/cadp.html]
CafeOBJ: An implementation of a specification language based on three-way extensions to many-sorted equational logic. The underlying logic is order-sorted (as well as many-sorted) and admits unidirectional transitions as well as equations. It also accomodates hidden sorts in addition to ordinary, visible sorts. CafeOBJ is an offspring of the family of algebraic specification techniques. A source code distribution of this GCL implementation is available. A user's manual is also available in PostScript format.
[http://www.ipa.go.jp/STC/CafeP/index.html]
Calc: This GNU package is an advanced calculator and mathematical tool that runs as part of the Emacs environment. Some of its features are arbitrary precision integers and floating-point numbers, algebraic manipulation features including symbolic calculus, graphics using Gnuplot, and extensive library of mathematical functions, etc. It comes with a 500+ page manual and is written in Elisp, the Lisp dialect in which Emacs is written, and as such must be compiled using Emacs. This further implies that you must have Emacs installed before you can use this. The source code file has a name of the form calc*.tar.gz.
[http://www.gnu.ai.mit.edu/order/ftp.html]
CALC: A calculator program for doing arbitrary precision integer arithmetic. This includes almost 60 built-in functions of interest to number theorists. It is written in ANSI C and portable to most platforms with an appropriate compiler. It is documented in an ASCII text file.
[http://www.maths.uq.edu.au/~krm/krm_calc.html]
calibr: A CCD camera calibration toolbox for Matlab. This implements a bias correction procedure for circular control points and a nonrecursive method for reversing the distortion model. See Heikkilä (2000).
[http://www.ee.oulu.fi/~jth/calibr/]
callback: A C++ library implementing callbacks to functions (function pointers), function objects, member functions, and member data taht are function pointers or function objects.
[http://www.primenet.com/~jakubik/callback.html]
Calypso: A prototype software system for writing and executing parallel programs on non-dedicated platforms using off-the-shelf networked workstations, operating systems, and compilers. Calypso features a simple programming paradigm which incorporates shared memory constructs, the separation of the program and the execution parallelism to allow programs to scale as computers join an ongoing computation, transparent use of unreliable shared resources via provision of dynamic load balancing and fault tolerance, and effective performance for large classes of coarse-grained computations.
Calypso programs are written in Calypso Source Language (CSL) which is essentially C++ with an added construct to express parallelism. CSL is based on a shared memory model and easy to learn and use. A unified set of mechanisms called eager scheduling and collating differential memory is used to provide the functionality of Calypso. Eager scheduling is a mechanism for assigning concurrently executable tasks to the available machines where any machine can execute any enabled tasks independent of whether the task is already being executed on another machine. This leads to free machines doing more work than loaded ones and a balanced system. Collating differential memory provides logical coherence and synchronization while avoiding false sharing. Memory updates are collated to assure exactly-once logical execution and they are transmitted as bitwise difference to prevent false sharing.
A Calypso distribution for Windows NT platforms has been released and a UNIX-based distribution for Sun SunOS and Solaris and Linux Intel platforms has been implemented but not yet (6/97) released. The details of the system are documented in some technical reports available in PostScript format.
[http://cs.nyu.edu/milan/calypso/index.html]
Calypso (PROLOG): A PROLOG compiler that produces native code. This also includes an efficient finite domain constraint solver. The features include:

conformance to the ISO PROLOG standard;

direct generation of assembler code;

a simple command-line compiler;

support for floats, streams, DCG and dynamic code;

more than 300 PROLOG built-in predicates and more than 50 FD built-in predicates;

a line editing facility under the interactive interpreter with completion on atoms;

a normalized interface with C; and

socket and operating system interfaces.

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

CAMAC-Linux

sjyLX

[http://www.ifh.de/~ole/camac/]
[http://www-ols.fnal.gov/ols/www/camac/GSinCAMAC.html]
CAMAC-Linux: A package of CAMAC device drivers. The CAMAC controllers supported are:

Aachen DBCC Controller with PCCPI Card

Wiener Camac Crate Controller CC16 with PC card PC16; and

Jorway 73A SCSI CAMAC Crate Controller with a PC SCSI adapter.

A source code distribution is available which includes a user's manual.
[http://www.ifh.de/ ole/camac/]
C.A.MAN: A Fortran 77 program designed for analyzing mixtures of densities from the exponential family. C.A.MAN supports mixture analysis of densities for several distributions including normal with single variance, Poisson, Laplace, exponential, Poisson for rates, normal with different variance, predefined density matrix, binomial and geometric. A source code distribution is available. See Böhning et al. (1992).
[http://ftp.ukbf.fu-berlin.de/sozmed/caman.html]
Cambridge Modula-3: A modified version of the DEC SRC Modula-3 system which includes an updated build system with configuration file support, language additions to allow debugging, support for gcc on Windows 95 and NT, and some primitive support for recovering from running out of virtual memory.
Distributions of Cambridge Modula-3 are available in source code form, as bootstrap binaries, or as minimal binaries. The bootstrap binaries contain the bare essentials needed to start compiling the rest of the system, while the minimal binaries also contain various additional packages. Binary packages are available for Linux Intel and Windows 95/NT platforms.
[http://www.cl.cam.ac.uk/m3doc/linux/cambridge.html]
Caml Special Light: This has been superseded by Objective Caml.
CAN: The Controller Area Network is a serial bus system protocol suited for networking intelligent devices as well as sensors and actuators within a system. CAN is a system with multi-master capabilities, i.e. all nodes are able to transmit data and several nodes can simultaneously request the bus. Subscribers or stations are not addressed, but rather prioritized messages are transmitted wherein a transmitter sends a message to all CAN nodes, and each node decides on the basis of the received identifier whether it should process the message. It is a simple protocol that can be implemented at low cost. A Linux driver for the CAN protocol can be found in the can4linux package.
[http://www.can-cia.de/]
can4linux: A Linux driver intended to provide a common API for a full-featured and sophisticated CAN development environment, where CAN is a two wire serial broadcast transmission protocol used in industrial control, hydraulic and automotive applications. The features of can4linux include:

dynamic runtime configuration via virtual files;

up to 4 CAN controllers/channels;

single packet transceiving/receiving (i.e. polling);

a fast FIFO transfer mode via read(), write() and select() calls;

full CAN emulation; and

sample applications including a simple CAN bus terminal (canterm) and a CAN monitor (MESSENGER) written in Tcl/Tk.

A source code distribution of CAN is available. Installation and use requires both LDDK and Tcl/Tk.
[ftp://ftp.llp.fu-berlin.de/LINUX-LAB/CAN/]
[http://www.llp.fu-berlin.de/pool/newproj/CAN/]
CANDYS/QA: A program to aid in the analysis of the numerical bifurcation of dynamical systems. The treatable classes of dynamical systems include:

autonomous systems with continuous time;

periodically forced systems with continuous time and fixed period; and

autonomous systems with discrete time steps.

CANDYS computes various invariant sets including steady states of systems of class 1, cycles of systems of class 1 where the period is calculated, and cycles of systems of class 2 and 3 where the period can be chosen. The functionality includes path following of the steady state or cycle with respect to a chosen system parameter. Various critical points can be calculated include:

saddle-node bifurcation points;

pitchfork and other bifurcation points;

period-doubling points;

Hopf bifurcation points; and

torus bifurcation points.

The unique features of CANDYS include:

several methods for computing a first point;

an efficient cubic predictor that yields a good guess of the next point;

calculation of different critical points as the solution of nonlinear systems of equations which can be freely combined;

solutions are computed as short paths for each critical point obtained from branching off solutions; and

graph structure bookkeeping for solution branches, critical points and temporary endpoints.

Applications included in the distribution are:

a truncated system of the Navier-Stokes and MHD equations;

a 7-D ODE model of solar activity; and

a 5-D ODE model of the dynamics of the photon-exciton interaction of an optical semiconductor.

A source code distribution is available which can be compiled and used on most UNIX flavors with an appropriate C++ compiler. This has been tested on G++ 2.7.2. A user's manual is available in PostScript format.
[http://www.agnld.uni-potsdam.de/~wolfgang/ca-ov.html]
CAP: The Columbia Appletalk Package implements the AppleTalk protocol stack on UNIX machines. The utilities in the package include:

aarpd, an AppleTalk Address Resolution Protocol (AARP) daemon;

atis, an AppleTalk information server and name registry for UNIX;

atlook, atlooklws and atpinger, for looking up Appletalk devices accessible from UNIX;

getzones, displays the AppleTalk zones visible to a host;

lwsrv, a LaserWriter spooling agent;

papif and papof, printer system input and output filters for printing to LaserWriters;

snitch, for responding to AppleTalk Inter*Poll requests;

aufs, an AppleTalk file protocol UNIX file server;

aufsmkkey, an AUFS distributed password global key tool;

aufsmkusr, an AUFS distributed password tool;

lwpr, iwpr, tlw, papif, lwsrv and isrv, provide UNIX access to AppleTalk printers and UNIX print spoolers for Appletalk; and

uar, a UNIX AppleTalk router.

The source distribution for CAP is available and can be installed on most UNIX platforms. On some UNIX boxes external hardware is needed to translate Appletalk into IP, but support for this is provided in the kernel for Linux and some other systems. The CAP system is documented in man pages and in various ASCII README files. See also netatalk, hfs_fs, hfsutils, MacGate, and Linux Services for Mac and Windows Users.
[http://www.cs.mu.OZ.AU/appletalk/cap.html]
CAP: The Culvert Analysis Program is a program that follows standard USGS procedures for computing flow through culverts. It can be used to develop stage-discharge relationships for culverts and to determine discharge through culverts from high water marks. It can compute flows for rectangular, circular, pipe arch, and other nonstandard-shaped culverts. CAP solves the 1-D steady-state energy and continuity equations for upstream water surface elevation given a discharge and a downstream water surface elevation.
A source code distribution of CAP for UNIX platforms is available. The primary documentation is contained within Fulford (1995). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/Cap.html]
[http://www.geogr.uni-jena.de/software/Cap.html]
Card Services: A complete PCMCIA support package for Linux platforms. It includes a set of loadable kernel modules (LKM) which implement a version of the PCMCIA 2.1 Card Services applications interface, a set of client drivers for specific cards, and a card manager daemon which can respond to card insertion and removal events by loading and unloading drivers on demand. It supports the hot swapping of PCMCIA cards so they can be inserted and ejected at any time. The current (6/97) package supports many ethernet cards, modems and serial cards, several SCSI adapers, and some SRAM and FLASH memory cards. All common PCMCIA controllers are also supported so it can run on most Linux-capable laptops. A list of supported devices is too long to reproduce here and can be found at the site.
The Card Services package is available in source code format. It is written in ANSI C and can be compiled and installed on Linux platforms. It and PCMCIA in general are documented in the Linux PCMCIA HOWTO and the PCMCIA Programmer's Guide, both of which are available in both HTML and PostScript format.
[http://pcmcia.sourceforge.org/]
CASA: A special purpose system for computational algebra and constructive algebraic geometry that runs on top of Maple. In CASA an algebraic set can represented implicity, in projected form, parametrically, and by places. The basic operations available include:

ideal theoretic operations (union, intersection);

creating algebraic sets in different representations;

generating curves of fixed multiplicities at given points;

intersection, union, and difference of algebraic sets

computation of tangent cones and tangent spaces;

computation of the dimension of an algebraic set;

decomposition into irreducible components;

transformations of algebraic sets to hypersurfaces; and

computation of the singularities, genus, neighborhood graphs and adjoint curves of an algebraic curve.

Several advanced operations are also available including:

rational parametrization of rational curves over an optimal extension field of coefficients;

implicitization of parametrically given algebraic sets;

Puiseux series expansions;

multivariate resultants;

Groebner bases of ideals and modules;

Groebner walk;

hybrid methods for finding solutions of an arbitrary system of equations;

computation of rational points on conics;

offset curves;

plotting both explicitly and implicitly given curves and surfaces;

computation of syzygy-bases; and

computation of multivariate polynomial codes and algebraic geometric codes.

Versions are available for Maple releases 4 and 5, with one for version 6 in the works.
[http://www.risc.uni-linz.ac.at/software/casa/casa.html]
Casbah: A project to build an integrated content management system for Linux that provides for web development, content creation, and content management. It is planned to be an extensible, multi-user, multi-platform environment for total content management. This project started in 1/98 and is still in its infancy.
[http://www.ntlug.org/casbah/]
CASE: The Cellular Automaton Simulation Environment is a toolkit for visualizing discrete models in 2-D, i.e. cellular automata. The goal of this project is to create an integrated framework for creating generalized cellular automata using the object oriented features of C++. The CASE tool consists of a classical finite state machine and a visualization system or presentation manager. A finite state machine is an abstract system which can exist in any of a discrete set of states or conditions, with the state at any instant characterized by the collective state of all of the individual cells which comprise the machine. The system evolves in time according to well-defined rules iteratively applied to each cell. An example is the Game of Life popularized by John Conway. The presentation manager can display the state of the simulation in a variety of user-configurable ways.
The principle class objects comprising CASE are:

CAApp, a main class used to control the application;

CAModel, a class responsible for updating the simulation according to a given set of rules;

CAVisual, a class responsible for all drawing and text output in the main window;

CACell, a class containing the elementary simulation particles which each one having a set of properties which can change in various ways during the simulation;

CAEnviron, an object which defines the pattern of cells in a simulation;

CAGrid, a superclass of all environs with fixed geometry; and

CAProperty, a class of properties for defining the states of cells.

There is also an X2Dview widget class for drawing and animation in 2-D coordinate systems which is compatible with X11R5.
A source code distribution of CASE is available. It is written in C++ and can be compiled with recent versions of g++. It is documented in a user's manual available in PostScript format.
[http://www.iu.hioslo.no/~cell/]
CASMSIM: A microassembler and simulator package for the Classic series of Hewlett-Packard (HP) handheld calculators. The Classic series includes the HP-35 Scientific, HP-80 Financial, HP-45 Advanced Scientific, HP-65 Card Programmable Scientific, HP-70 Business and HP-55 Programmable Scientific models. It is written in C and runs under UNIX with X11. A source code distribution is available under the GPL.
[http://www.brouhaha.com/~eric/hpcalc/csim/]
Cassowary: An incremental constraint solving toolkit that efficiently solves systems of linear equalities and inequalities. Constraints can be either requirements or preferences, with client code specifying the constraints to be maintained. The solver updates the constrained variables to have values that satisfy the constraints. A source code distribution of this C++ package is available. Compilation requires the egcs package. The distribution contains sample applications written in Smalltalk, C++, Java and Python.
[http://www.cs.washington.edu/research/constraints/cassowary/]
Castor: A Java package that provides Java to XML binding, Java to SQL/LDAP persistence, and various other things. The features include:

Castor XML, i.e. Java object to XML document;

Castor JDO, i.e. Java object persistence to RDBMS;

Castor DAX, i.e. Java object persistence to LDAP;

Castor DSML, i.e. LDAP directory exchange through XML;

an XML-based mapping file specifying the mapping between one model and another;

support for schema-less Java to XML binding;

reduction of JDBC operations via in-memory caching and write-at-commit;

two-phase commit transactions, object rollback and deadlock detection;

OQL query mapping to SQL queries; and

EJB container managed persistence provider for OpenEJB.

[http://castor.exolab.org/]
Catalog: A Perl program for creating, maintaining and displaying Yahoo-style directories that uses the MySQL database as a back-end. This produces such a catalog by organizing objects in a structured tree as records in a database table. The structured tree is a set of tree nodes and relations between those nodes. The features and functionality include:

displaying structured trees of resources;

displaying chronologically-ordered resources and an associated calendar;

displaying alphabetical indexes of resources;

full text search in the resources and category names;

HTML-based catalog administration;

on-line editing of resource records;

an arbitrary number of catalogs;

use of mod_perl and Apache for high performance;

customization of user view via HTML templates;

defining more than one view of the same catalog;

loading/unloading of thematic catalogs in XML; and

creating an HTML dump of a structured tree for publishing a static version.

A source code distribution is available which is documented in a reference guide and user's manual.
[http://www.senga.org/]
catdoc: A program that translates Microshaft Word documents into ASCII format. It can optionally replace some characters with multicharacter sequences such as TeX commands. The package also includes a Tcl/Tk script called wordview that allows Word files to be viewed on X terminals. A source code distribution is available.
[http://www.fe.msk.ru/~vitus/catdoc/]
CAVITY: A collection of Fortran programs dealing with the solution of the Navier-Stokes equations (NSEs) in a 2-D cavity including:

CAVSMV, compares several methods for performing the sparse matrix-vector product;

CAVCDR, solves the sparse linear equation arising in the solution of the nonlinear NSEs using part of the ODEPACK solver LSODES;

CAVADD, solves the sparse linear equation from the nonlinear NSEs using the iterative solver BICGSTAB;

CAVBIH, solves the steady state NSEs using the fast biharmonic solver BIHAR;

CAVNL1, solves the steady state NSEs using the solver NLEQ1;

CAVALC, solves the steady state NSEs using the continuation code ALCON2;

CAVPIT, solves the steady state NSEs using the continuation code PITCON;

CAVLSO, solves the time-dependent NSEs using LSODES from ODEPACK;

CAVVOD, solves the time-dependent NSEs using VODPK, a variable coefficient ODE solver with the preconditioned Krylov method GMRES;

CAVNSS, solves the steady state NSEs using the nonlinear solver NS02AD and CDRV to solve the sparse linear equations;

CAVGIA, solves the steady state NSEs using the nonlinear solver GIANT with GMRES used to solve the sparse linear equations;

CAVARP, calculates some of the eigenvalues and eigenvectors of the sparse unsymmetric Jacobian matrix for the NSEs; and

CAVNKS, solves the steady state NSEs using the nonlinear Krylov solver NKSOL.

[ftp://blas.cis.mcmaster.ca/pub/fred/cfd/cavity/]
CBB: A package for managing personal finances written in Tcl/Tk and Perl. The features include:

creating, editing and deleting transactions with the running balance automatically calculated;

several input accelerators to save data entry work;

splitting the value of a transaction across multiple categories;

undo for the last transaction insert, edit or delete;

handling multiple accounts and transfers between accounts;

a simple interface for user written reports and graphs;

importing from and exporting to Quicken file format; and

several contributed tools with additional features.

A source code distribution of CBB is available. It includes an extensive manual available in the usual formats.
[http://www.menet.umn.edu/~curt/cbb/]
C-Breeze: A compiler infrastructure for analyzing ANSI C programs. C-Breeze parses a C program into an abstract syntax tree (AST) that can be traversed or modified. It can also unparse the AST and produce another C program as output. A major use is to read in a C program, perform some transformations on it, and then write the transformed program for compilation. C-Breeze is written in C++ and is organized into a series of phases. Phases are provided to:

parse source code into an AST;

dismantle the AST to a low-level intermediate representation;

build a control flow graph;

convert to SSA form; and

perform a context-sensitive interprocedural pointer analysis.

New phases can be added by using a design pattern through built-in phases to traverse and change the AST.
[http://www.cs.utexas.edu/users/c-breeze/]
CBRP: The Client Based Routing Protocol is a routing protocol designed for use in mobile ad hoc networks. It divides the nodes of the ad hoc network into a number of overlapping or disjoint clusters in a distributed manner.
[http://www.ietf.org/internet-drafts/ draft-ietf-manet-cbrp-spec-00.txt]
CCA: The Common Component Architecture defines a minimal set of standard features that a high-performance component framework should provide, or can expect, to be able to use components developed within different frameworks. The standard is intended to promote interoperability between components developed by different groups across different institutions. The elements or components of the standard include:

a Scientific IDL describing the input and output types of components as well as their relationships;

Gports, a standard encompassing the functionality needed to organize component interactions within any CCA-compliant framework;

Framework Services that provide a framework abstraction that can be used in the component stub implemention as well as directly by the components;

a Configuration API encompassing the functionality needed for the component to interact with the builder and vice versa; and

a Repository API defining the functionality needed to search a framework repository for components as well as manipulate components within the repository.

[http://www.acl.lanl.gov/cca/]

Babel

A project for developing language interoperability technology in support of the CCA forum. Babel defines a component interoperability architecture consisting of:

an Interface Definition Language (IDL);

mappings of the IDL onto programming languages of interest (e.g. Fortran 77 and 90, C, C++, Java and Python); and

library services such as reference counting, dynamic type identification, reflection and a dynamic invocation interface.

This borrows concepts from both CORBA and JavaBeans.
[http://www.llnl.gov/casc/babel/]

CCAT

The Common Component Architecture Toolkit is an implementation of the CCA specification that describes the construction of portable software components that may be re-used in an CCA-compliant runtime framework. The CCAT architecture is based on five service components:

Directory Service, a tool allowing a component to browse remote directories containing information about component specifications;

Registry Service, a tool allowing a component to browse remote directories containing information about running instances of components;

Creation Service, a tool allowing a component to instantiate another component;

Connection Service, a tool allowing one component to connect the ports of one component to those of another; and

Event Service, a tool allowing components to publish and subscribe to events.

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

CALCOR, which subtracts dark or flash calibration data from a series of bias-corrected NDFs (i.e. the N-dimensional Data Format used by most Starlink applications);

CCDALIGN, an interactive procedure to aid in the alignment of NDFs;

CCDCLEAR, which removes specific parameters from the globals file;

CCDEDIT, which edits NDF extensions;

CCDFORK, which creates a script for executing commands in a background process;

CCDNDFAC, which accesses a list of NDFs and writes their names to a file;

CCDNOTE, which adds a note to the current log file;

CCDSETUP, which sets the global parameters;

CCDSHOW, which displays the value of the global parameters;

DEBIAS, which performs the debiassing and initial preparation of data;

FINDCENT, which centoids image features;

FINDOBJ, which locates and centroids image features;

FINDOFF, which performs pattern-matching between position lists related by simple offsets;

FLATCOR, which divides a series of NDFs by a flatfield;

IDICURS, which reads coordinates from an X display device;

IMPORT, which imports FITS information into NDFs;

MAKEBIAS, which produces a master from a set of bias frames;

MAKECAL, which produces a dark or pre-flash calibration NDF;

MAKEFLAT, which produces a flatfield calibration NDF; MAKEMOS, which makes a mosaic by combining and normalizing a set of NDFs;

PAIRNDF, which displays and manipulates image pairs to allow easy registration;

PLOTLIST, which draws position markers on a graphics display;

PRESENT, which presents a list of NDFs;

REGISTER, which determines transformations between lists of positions;

SCHEDULE, which schedules and automated reduction;

TRANLIST, which transforms lists of positions; and

TRANNDF, which transforms a list of NDFs by resampling.

A binary version of CCDPACK is available for DEC Alpha, Linux Intel, and Sun Solaris platforms. It is documented in a 170 page user's manual available in TeX DVI or PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
CCF: Collaborative Computing Frameworks is a suite of software systems, communications protocols, and other tools that enable collaborative, computer-based cooperative work. The package constructs a virtual work environment called a Collaboratory on multiple computers systems connected via the Internet. The goal of the project is to evolve a virtual environment for distributed computation that supports integrated human audiovisual communication, high performance heterogeneous computing, and distributed data management facilities.
The programs comprising CCF include:

ccfsns, the Session Name Server which provides a lightweight name service for maintaining names and attributes of sessions, participants and CCTL channels;

cctlwp, the multicast White Pages server;

ccsm, a virtual desktop for application sharing, i.e. the primary user interface for CCF;

ccfx, a program launched by ccsm to create a distributed pseudo-X server;

ccds_s, the Data Space data server;

ccdssh, a shell user interface to the Data Space server;

ccfaudio, an audio communication tool;

ccfchat, a text communication tool;

ccfcb, a clearboard tool; and

ccdssh, a dataspace tool.

A source code distribution of CCF is available as are binary distributions for several platforms including Linux Intel. Documentation is contained within several ASCII README files scattered through the distributions.
[http://emily.mathcs.emory.edu/ccf/]
ccheck: A program that implements CCEL, a metalanguage for C++ that allows software developers to express constraints on C++ designs and implementations.
[ftp://ftp.cs.brown.edu/pub/ccel/]
ccmalloc: A memory profiling and malloc debugging library for C and C++ programs which can locate leaks, multiple deallocations, and memory corruptions. It also detects under writes and over writes, detects writes to already deallocated data, compiles allocation and deallocation statistics, applies to optimized and stripped code, provides file and line number info for the whole call chain, requires only linking with the library and no recompilation, efficiently represents call chains, sorts, has customizable resource usage, and pretty prints call chains. A source code distribution of ccmalloc is available. It is written in C and can be compiled on most available C compilers.
[http://iseran.ira.uka.de/~armin/ccmalloc/]
CCP5: A library of programs related to molecular dynamics, Monte Carlo algorithms, lattice statics and lattice dynamics. The programs in the library include:

ADMIXT, for the molecular dynamic simulation of atomic mixtures where interatomic forces consist of short range Lennard-Jones atom-atom forces;

CARLOS, a Monte Carlo variable site-site model for thermodynamic properties;

CARLAN, for structural analysis of CARLOS results;

CURDEN, calculates current density correlations via Fourier transforms in space and time;

DENCOR, calculates correlation functions via the Fourier transform;

DL_POLY, a parallel molecular dynamics simulation package;

and many more. Most are written in Fortran 77 although a few are written in C.
[http://www.dl.ac.uk/CCP/CCP5/librar.html]
ccscript: Yet another highly specialized embedded scripting engine for creating extensible applications. Ccscript is a C++ class library from which application-specific dialects of the core language can be derived as needed. It is derived from Common C++, originating as a set of extras for that package. This differs from other embedded scripting engines in that it is meant to step execute from a callback service thread, i.e. it executes a single step statement instead of invoking a function which then parses an interpreter. This is useful, e.g. when a callback service thread in monitoring multiple devices. Each device can have an interpreter instance, and a single thread can dispatch events upon demand. It is specifically designed for scripting state-event systems, and for doing so where execution deadlines are short, e.g. in the Bayonne project.
[ftp://www.voxilla.org/pub/ccscript/]
ccsh: A scripting language intended to be powerful and easy to use for those already familiar with C. Code written in ccsh is transformed into bytes of data to be run directly by the CPU rather than interpreted at an intermediate step like bash and other shells. This can lead to dramatic increases in speed of execution. The features include:

no setuid problems since the setuid bit will do nothing;

fast execution for large (1000+ lines) applications;

easy of programming via the resemblance to C; and

portability to any platform with a C compiler.

[http://fire.csua.ucla.edu/~dannys/projects/ccsh/]
CC65: A C compiler for 6502 processor based systems. CC65 is a descendant of Small C with several extensions and without some of the limits of the latter. The compiler is almost ISO C compatible so sources from other systems should be easily translatable. The compiler differences are listed at the site. The assembler is a one-pass macroassembler able to create output for the 6502, 65SC02 and 65SC816. The linker has a flexible output format and can support ROM-able code (i.e. different load and run addresses for data), systems with multiple ROMs, unlimited segments, more than one BSS segment, etc. The runtime and standard C libraries have been designed to be portable and as such support the Commodore C64, C128, C16, C116, Plus/4 and 600/700 computer families. Full sources and binaries are available for several host systems including Linux Intel and Microshaft systems. A large amount of documentation is available in ASCII format.
[http://www.von-bassewitz.de/uz/cc65/]
CDAT: The Climate Data Analysis Tool was developed for analyzing climate data by performing complex mathematical calculations and graphically displaying the results. CDAT provides the tools needed to diagnose, validate and intercompare large observational and global climate model data sets. This uses Python as a central module or scripting language that allows the capabilities of all of the individual components to be used in a centralized way. The modular design of CDAT also enables user-designed C, C++ or Fortran routines to share modules and routines in collaborative projects. This provides a convenient and efficient way for reading different file formats and analyzing data from several different projects.
CDAT Python modules that perform the functions of existing projects include:

cdunif, for reading files in CDF, NetCDF, HDF, DRS and GrADS/GRIB formats;

VCS, for visually displaying and animating ingested or created data;

LATS, which outputs data in NetCDF or GrADS/GRIB formats;

CLI, a command line interface module that allows CDAT to receive argument and function input via the command line;

GUI, a graphical user interface module that allows CDAT to receive argument and function input via a point-and-click interface;

Numeric, which supplies the math functions needed for climate data manipulation;

PCMDI, contains miscellaneous functions like a regridder that transforms data from one model grid to another;

CDTIME, for converting different time units; and

CDR, a collection of climate diagnostic routines.

Binary versions of the CDAT package are available for SGI IRIX, Linux Intel and Sun Solaris platforms. It is documented in a 100+ page user's manual available in PDF format.
[http://www-pcmdi.llnl.gov/software/cdat/]
cdb: A fast, reliable and lightweight package for creating and reading constant databases. It was designed to be used in mission-critical applications like email, with database replacement being safe against system crashes. The features of the cdb database structure include fast lookups, low overhead, no random limits, fast atomic database replacement, and fast database dumps. A source code distribution of cdb is available.
[ftp://koobera.math.uic.edu/www/cdb.html]
CD Backup: A collection of Perl scripts for backing up large files onto various media, mainly CDs. This includes a modified version of BackBurner that takes a list of files and individually tars and gzips them. It also creates a database of the archived files at the beginning of the storage media (or on the first media of a multiple set). This is used by an extraction program to retrieve data on a saved set. The capabilities include:

creating an archive in a file;

creating an archive on a CD;

creating an archive on mountable media;

retrieving files on the first media;

listing files in an archive;

reading a file from spanned media; and

recursing directories to find files.

[http://cdbackup.home.dhs.org/]
CD Builder: A program for generating cue sheets and subcodes for creating CD-ROMs for CD-R drives capable of reading DAO and raw modes.
[http://www.ccs.neu.edu/home/bchafy/cdb/cdb.html]
cdda2wav: A utility that can sample data from CD-ROM drives and dump it into WAV or Sun format sound files, i.e. a CD ripper. This has since been rewritten and expanded as cdparanoia.
[ftp://ftp.gwdg.de/pub/linux/misc/cdda2wav/]
cd-discid: A program that extracts information such as the number of tracks and the offset of each track from a CD.
[http://lly.org/~rcw/cd-discid/]
cddump: A Perl wrapper around mkisofs and cdrecord that behaves similarly to the dump utility. This enables backing up files to single or multiple CDs. The similarities to dump include:

performing full, differential or incremental dumps via levels 0 through 9;

multi-volume dumps; and

maintenance of an /etc/cddumpdates file to record backup dates and levels.

Additional functionality includes:

writing to CD recordable or rewritable media;

saving in standard ISO-9660 format with no special utility required for restoring;

doesn't save empty directories or directly save device nodes, FIFOs or any other files not supported by ISO-9660; and

appending any level of d ump onto remaining space on partially-used media.

[http://users.gtn.net/fraserm/cddump.html]
CDE: The Common Desktop Environment is a real pig of a GUI for UNIX/X11 systems. There is an introductory article about the CDE in the March 1998 issue of the Linux Journal.
CDF: The Common Data Format is a self-describing data abstraction for the storage and manipulation of multidimensional data in a discipline-independent format. The CDF distribution contains a library of functions for creating CDF applications as well as a toolkit of programs for performing various CDF manipulations. The toolkit includes:

CDFedit, for displaying, creating, and modifying attribute and variable data in a CDF;

CDFlist, for sequential (i.e. flat) viewing of filtered variable data;

CDFwalk, for direct and sequential access to related variable values;

CDFconvert, for changing the format, encoding, and majority of a CDF;

SkeletonCDF, for reading a specially formatted text file and creating a skeleton CDF;

SkeletonTable, for reading a CDF and producing a specially formatted text file called a skeleton table;

CDFinquire, for displaying the CDF version number as well as the default toolkit qualifiers;

CDFstats, for producing a report containing various statistics about the variables in a CDF;

CDFcompare, for reporting the differences between CDFs; and

CDFdir, for producing a directory listing of a CDF's files.

A source code distribution of CDF is available for generic UNIX platforms. It is documented in a user's guide and separate reference manuals for the Fortran and C interfaces.
[http://nssdc.gsfc.nasa.gov/cdf/cdf_home.html]

makeCDF

A toolf or reading in flat data sets in both binary and text form and generating CDF datasets from them. MakeCDF is written in standard ANSI C and still (12/97) under development.
[http://nssdc.gsfc.nasa.gov/space/spdf/makecdf.html]
CDFLIB: A library of Fortran routines for computing the cumulative distribution functions, inverses and parameters of the distribution for beta, binomial, chi-square, noncentral chi-square, F, noncentral F, gamma, negative binomial, normal, Poisson, and Student's t distributions. Given values of all but one parameter of a distribution, the other is computed. The source code is available and the documentation is contained within the code itself as well as in ASCII files within the distribution.
[http://www.stat.cmu.edu/general/]
CDIF: The CASE Data Interchange Format provides a set of vendor- and method-independent definitions for metadata concepts in general and for modelling data and related concepts in particular. Most specifically it defines the CDIF Integrated Meta-model, a multi-faceted, integrated, multi-disciplinary information model for modeling concepts. It also defines standard ways of moving information between tools without the need for customized interfaces, e.g. the CDIF Transfer Format for representing models. An additional transfer format based on XML is also in development.
[http://www.cdif.org/]
[http://www.oasis-open.org/cover/xml.html]
CD Index: An Open Source replacement for the CDDB system for looking up audio CDs via the Internet. The project goals include:

using the MySQL database server to store the data;

creating a system that allows data mirroring without an authoritative central node;

allowing instant web-based CD submission;

distinguishing single artist from multiple artists CDs;

eventually including MP3s as well as CDs;

using XML to exchange and mirror the data; and

extensive searching capabilities.

[http://www.cdindex.org/]
cdk: The Curses Development Kit is a package of widgets for creating Ncurses-based full-screen user interfaces. Each widget can display color or other character attributes, with cdk including an attribute/color format command set which allows the simple adding of colors and attributes.
The available widgets include:

Alphalist, which allows a user to select from a list of words;

Calendar, a simple calendar widget;

Dialog, which prompts the user with a message to which a response can be made from provided buttons;

Entry, which allows information entry;

File Selector, a file selector written from lower-level widgets;

Graph, which draws a graph;

Histogram, which draws a histogram;

Item List, which creates a pop-up field allowing a user to select one of several choices;

Label, which displays messages in a pop-up box;

Marquee, which displays a message in a scrolling marquee;

Matrix, which creates a complex matrix iwth lots of options;

Menu, which creates a pull-down menu interface;

Multiple Line Entry, which creates a multiple line entry field;

Radio List, which creates a radio button list;

Scale, which creates a numeric scale;

Scrolling List, which creates a scrolling list/menu list;

Scrolling Window, which creates a scrolling log file viewer;

Selection List, which creates a multiple option selection list;

Template, which creates an entry field with character sensitive positions; and

Viewer, which is a file/information viewer useful for displaying lots of information.

The distribution contains the source code which is written in C. The library has been compiled on Sun SunOS and Solaris, IBM AIX, HP-UX and Linux Intel platforms. Each of the widgets is extensively documented in a separate man page.
[http://www.vexus.ca/CDK.html]
cdlabelgen: A program that creates frontcards and traycards for CDs in PostScript format. This will print titles/subtitles and date information in a format such that it can be seen on the endcaps of a CD jewel box. A source code distribution is available which requires Perl 5.003 or greater.
[http://www.red-bean.com/~bwf/software/cdlabelgen/]
cdparanoia: A CD ripping application for Linux that directly reads audio from a CD as data (with no analog step) and writes the data to a file or pipe in WAV, AIFC or raw 16-bit linear PCM format. It contains few extra features but instead concentrates on the ripping process and on knowing as much as possible about the hardware on which it is operating. As such it will robustly read data from inexpensive drives that are prone to misalignment, frame jitter and loss of streaming during atomic reads. It can also read and repair data from CDs that have been damaged. Cdparanoia is easy to use despite an apparent lack of features, i.e. it autodetects the CD, its type, its interface, and other aspects of the ripping process at runtime. This enables a single binary to be adequate for a wide range of hardware.
A source code distribution of cdparanoia is available. It contains the standalone cdparanoia application as well as the cdda_interface and cdda_paranoia libraries that make it possible to add ripper functionality to any application. It is a complete rewrite of the similar cdda2wav application. A graphical interface to this is ripperX.
[http://www.xiph.org/paranoia/]
CDRDAO: A program for recording audio CD-ROMs in disk-at-once (DAO) mode based on a textual description of the planned contents. In DAO mode the complete disc is written in a single step. The features include:

full control over the length and contents of pre-gaps;

control over sub-channel data, e.g. catalog number, ISRC code, index marks, and copy, pre-emphasis, 2-/4-channel flags;

support for exact audio or data CD copying;

composing trakcs of different audio files supporting non-destructive cut;

accepts both WAVE and raw audio files; and

CD-TEXT reading and writing on supported drives.

[http://www.ping.de/sites/daneb/cdrdao.html]
cdrecord: A package for recording audio or data compact discs (CDs) from a master image. This is usable with more UNIX flavors and with more types of CD-R drives than any other available package.
[http://www.fokus.gmd.de/research/cc/glone/employees/joerg.schilling/private/cdrecord.html]
CDRIV/DDRIV/SDRIV: A package of Fortran routines for solving ordinary differential equations (ODEs) with initial conditions, i.e. IVPs. The different versions are for, respectively, single precision, double precision, and complex precision ODEs. There are also three versions of each of these which have increasing degrees of flexibility and complexity. CDRIV1 is the simplest and should be used for routine problems with no more than 200 ODEs. It uses a numerical approximation of the Jacobian matrix of the right hand side and the stiff solver option. CDRIV2 is used for problems for which CDRIV1 is inadequate. It contains a nonstiff equation solver and a root finding option in addition to the capabilities of CDRIV1. CDRIV3 is the most flexible and complex of the programs. Its additional features include the ability to exploit band structure in the Jacobian matrix, the ability to solve some implicit DEs, the option of integrating in the one step mode, the option of allowing the user to provide a routine to compute an analytic Jacobian matrix, and the option of allowing the user to provide a routine to perform the matrix algebra associated with corrections to the solution components.
The CDRIV/DDRIV/SDRIV program suite is available as Fortran 77 source code. The use of each is documented in comment statements within the source code files. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
CD-ROM: Information sources for those interested in reading from and writing to CD-ROMs are:

CD-Recordable FAQ
http://www.fadden.com/cdrfaq/

Linux CD-ROM Page
http://www.anime.net/~goemon/linux-cd/

Primer on CD-R
http://resource.simplenet.com/primer/primer.htm

Software pertaining to CD-ROMs includes;

abcde, a front-end program that grabs a CD, converts each track to MP3 format, and ID3-tags each file;

bchunk, converts CD images in raw format to ISO and CDR format;

BladeEnc, an MP3 encoder;

BurnIt, a graphical frontend to cdrecord written in Java;

CD Backup, a set of scripts for backing up large files onto various media, e.g. CDs;

CDBuilder, a tool for generating CD cue sheet and subcodes for burning audio CDs;

cdda2wav, a utility for sampling, i.e. stripping, from CD-ROMs;

cd-discid, extracts the number of tracks and the offset of each track from a CD;

CD Index, a system for looking up information about audio CDs via the Internet;

cdlabelgen, creates CD labels in PostScript format;

CDM, a project for CD mirroring and authoring;

cdparanoia, a CD ripper application;

cdr, a front-end for creating, duplicating and ripping CD-ROMS;

CDRDAO, a program for recording audio CD-ROMs in DAO mode;

cdrecord, a CD writing application (probably the best and most widely applicable);

CD-Tux, a command line front-end for burning audio and data CDs;

cdwrite, a CD writing application;

8hz-mp3, an MP3 encoder;

ERoaster, a graphical front-end for making ISO images and burning CD-ROMs;

gcombust, a GUI for mkisofs and cdrecord;

Gnome Toaster, a CD creation suite for authoring and copying audio, data and mixed-mode CDs;

GramoFile, for transferring audio tracks from vinyl records onto CDs;

grip, a front-end for CD ripping;

id3, a program for tagging MP3s with their title, artist, album and track number information;

jack, a front-end for CD ripping;

jcd, a Java CD player;

KisoCD, for creating data CDs;

Kover, creates covers for CDs;

Krabber, a front-end to several CD-ROM creation programs;

libcdaudio, a multi-platform CD player development library;

mkhybrid, for creating ISO-9660/HFS/JOLIET shared hybrid CD volumes;

mkisofs, a premastering program for generating ISO-9660 file systems for writing onto CD-ROMs;

mp3enc, an MP3 encoder;

Mp3Make, which automates the ripping and coding of CD audio to mp3 files;

RipIT, for creating MP3 files from an audio CD;

UDF, a project to incorporate support for the UDF file system in the Linux kernel;

webCDwriter, makes a single CD writer available to all users in a network;

X-CD-Roast, a CD writing application; and

YaRET, a Perl script that automates the process of ripping, encoding and tagging audio CDs.

[http://www.fokus.gmd.de/net/employees/schilling/cdb.html]
[http://www.cd-info.com/]
cdt: A portable container data types library that provides a uniform interface to manage objects in dictionaries based on various storage methods, e.g. list, stack, queue, ordered set/multiset, and unordered set/multiset. Each dictionary consists of a discipline to describe objects and attributes and a storage method to specify storage mechanisms. The disciplines can be used to create dictionaries that are either set-like (i.e. addressed by object comparisons) or map-like (i.e. addressed by keys) as well as to share objects across dictionaries that may even reside in different processes. Storage methods define how objects are stored and accessed. Currently (12/97) available methods include:

dtset, which stores unique and unordered objects in a dynamically grown hash table with move-to-front chains;

dtbag, which stores repeatable and unordered objects in a dynamically grown hash table with repeated objects kept together;

dtoset, which stores unique and ordered objects in a splay tree;

dtobag, which stores repeatable and ordered objects in a splay tree;

dtlist, which stores repeatable and unordered objects in a list with objects always inserted in ront of some current position pointer;

dtstack, which stores repeatable and unordered objects in a stack in reverse order of insertion; and

dtqueue, which stores repeatable and unordered objects in a queue in order of insertion.

A source code distribution of cdt is available. It is written in C and can be used from both C and C++ programs. It is documented in a technical report available in PostScript format.
[http://www.research.att.com/sw/tools/cdt/]
CDT: A Fortran 77 code that implements an algorithm for the asymmetric traveling salesman problem. The method is based on the assignment problem relaxation and on a subtour elimination branching scheme. The efficiency of the method is increased via reduction procedures and the parameteric solution of the relaxed problems associated with the nodes of the branch-decision tree. This is TOMS algorithm 750 and is documented in Carpaneto et al. (1995b) and Carpaneto et al. (1995a).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
CD2Mp3: A front-end to cdda2wav and lame that makes it easier to create MP3s from ripped CDs.
[http://sertaozinho.org/cd2mp3/]
CD-Tux: A console based CD recording front end built using Ncurses. The features include:

full support for mixed-mode CDs;

support for several audio formats including .au, .wav, .raw, .cdr and .mp3;

pre-made ISO images;

bootable CDs w/ test writes;

dynamic speed selection;

preview playing of audio tracks;

multisession disks; and

online help.

Source code and binary distributions are available.
[http://www.datadictator.co.za/cdtux/]
cdv: A cartographic visualization program in which geographic entities are represented by geometric symbols, with each symbol represented as an object with defined visual characteristics such a color, size and texture. With cdv dynamic maps can be created, e.g. a slider bar can be used to specify time and moved to advanced the map through time. Items can also be tagged with data values which can be used to visually display information or to retrieve the figures via interrogation with the mouse. Two versions of the software are available. The first is for enumerated data which can be expressed in chloropleth maps, scatter plots, and similar views. The second is for time-space data, allowing temporally varying spatial views to be explored as time series animations.
Source code distributions of both versions of cdv are available. Both require the use of Tcl/Tk versions 7.6 and 4.2 or newer, respectively. Documentation is scattered about the site and the distribution.
[http://www.mimas.ac.uk/argus/Software/CartoViz/]
cdwrite: A program used to record data or audio compact discs (CDs) on an Orange Book CD-ROM recorder. This will only write single session, Red/Yellow Book compatible discs. It is known to work with Philips CDD-521 and CDD-522, Kodak 522, and Yamaha CDR100 writers. A source code distribution of cdwrite is available. It is written in C and can be compiled on most UNIX flavors. It is documented in a man page. A X front-end for this and the related mkisofs program is X-CD-Roast.
[http://sunsite.unc.edu/pub/Linux/utils/disk-management/]
ce: A full-screen X Window based editor. The features include multiple editing sessions, rectangular cut and paste, command macros, vertical and horizontal scrolling, and global bounded search and replace.
[ftp://ftp.std.com/ftp/vendors/ETG/]
CEA Miscellaneous Utilities: A collection of miscellaneous utilities and libraries for UNIX platforms. This collection includes:

appendpaths, for concatenating paths and eliminating redundant components;

bundle, archives ASCII files using the shar format;

catport, for communicating with a remote port;

cleanenv, a meta-level file interpreter that purges an environment;

gmtime, converts ASCII UNIX seconds to other ASCII formats;

locallog, for handling local asynchronous message logs;

netio, network service access routines;

printenv, print all or part of an environment;

pslabel, a PostScript filter to add identifying labels;

purgepath, to purge unwanted components from a path;

slock, surrogate locks;

strptime, a wrapper around strptime; and

timegm, to convert ASCII GMT to ASCII UNIX seconds.

A source code distribution is available which has been compiled on Sun and Linux Intel boxes.
[http://www.cea.berkeley.edu/~pubinfo/html/CEA_freeware.html]
Cecil/Vortex: Cecil is a purely object-oriented language intended to support the rapid construction of high quality, extensible software. It incorporates multi-methods, a simple prototype-based object model, a mechanism to support a structured form of computed inheritance, module-based encapsulation, and a flexible static type system that allows statically- and dynamically-typed code to mix freely. It was developed to maximize the ability to quickly develop software and to reuse and modify existing software, and as such is based on a pure object model wherein all data are objects and objects are manipulated solely via message passing. It includes a general form of dynamic binding based on multiple dispatching to facilitate the message passing.
A Cecil standard library defines a collection of data and control structures used by most Cecil programs. The library is conveniently divided into five sections. The first includes basic data types such as void, int, float, char, pair, and triple. The second contains basic control structures such as bool and closure data types and if and while control structures. The third part consists of collections including arrays, sets, hash tables, strings, lists, etc. The fourth part includes streams and file-based I/O operations. The last part is a mixed bag containing some system operations as wel as some other data types and operations.
Vortex is an optimizing infrastructure for object-oriented and other high level languages. It is a language-independent optimizing compiler back-end with front-ends for Cecil, Java, and C++. It performs whole-program analyses by tracking intermodule dependencies in a program database which enables it to determine which compiled files must be recompiled after a programming change. The compiled code and libraries for each program are tuned to that application and cannot be shared with other applications. Vortex compilation occurs in three phases. In Phase Zero, the Vortex front-end translates non-Cecil programs in a Vortex RTL intermediate language. Phase One sees the RTL or Cecil sources translated into either C++ or assembly code. In Phase Two a C++ compiler or an assembler translates this output into object files and an executable.
Binary distributions of the Cecil/Vortex package are available for several platforms including Linux Intel. A large amount of documentation is available in various forms including user's manuals and technical reports.
[http://www.cs.washington.edu/research/projects/cecil/cecil/www/cecil-home.html]
Cecilia: A music and sound production system which uses Csound as its sound processing language. The principal goal of Cecilia is to enhance sound production by proposing a powerful design interface and a number of fast tools in an integrated environment in which a Csound tasks will enjoy a large productivity boost. It was designed to address Csound problem areas such as real-time interaction, the specification of time-varying functions, the interplay of Csound with other vital production functions (e.g. formatting, playing, and editing audio files), referencing on-line documentation, and the specification of complex scores.
The features of Cecilia include:

a number of graphical objects to specify control data for Csound orchestras;

a text editor with a number of built-in functions to improve orchestra and score design;

the integration of all currently defined Csound functions under menus, buttons, and hot-keys;

documentation in the form of interactive manuals with automatic opcode entry;

real-time control slider and option boxes;

complete file type rules and icons;

colorized orchestra keywords;

full search and replace;

a number of prefabricated modules to accomplish generic sound processing functions such as delays, reverbs, flangers, stretchers, resonators, etc.;

a scratch editor; and

record and loop-record from the outside world.

Cecilia is written entirely using Tcl/Tk and currently (7/97) is available in executable form for SGI IRIX and Linux Intel platforms.
[http://www.musique.umontreal.ca/CEC/]
Ceilidh: Collaborative software for threaded discussions with file attachment and email notification. The features of Ceilidh include:

written in C for speed;

platform independence with no plug-ins;

flexible user authentication;

automatic message expiration for maintenance-free operation;

a threaded message index for a structured message hierarchy;

smart HTML;

editing and deleting messages;

file attachments including documents, graphics and multimedia;

optionally encrypted mesages;

a Web-based administration tool; and

a database interface to SQL or other databases.

The freely available version is limited to only one forum. Binary distributions of this version are available for a wide range of platforms.
[http://www.g0rvx.demon.co.uk/]
CELEFUNT: A set of Fortran programs for testing complex elementary functions. This is TOMS algorithm 714 and is documented in Cody (1993a).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]

celefunt-x86

A version of CELEFUNT modified to work with x86 and 68xxx processors.
[ftp://members.aol.com/n8tm/home.html]
Cellular: The Cellular system for simulating cellular automata consists of a programming language Cellang, an associated compiler cellc, an abstract virtual cellular automata machine avcam, and a viewer cellview. Compiled Cellang programs can be run with input provided at any time during execution, and the results can either be directly viewed or written to an external file and later viewed using cellview. Cellang combines the classic cellular automata programming paradigm with that of agents which allows a richer solution space to many interesting problems.
Additional Cellang features include: any number of dimensions; the compile time specification of the size of each dimension; cell neighborhoods of any size and shape; positional and time-dependent neighborhoods; associating multiple values (fields), including arrays, with each cell; associating a potentially unbounded number of mobile agents with each cell; and local interactions only.
The Cellular distribution is available as source code written in C and can be installed on most generic UNIX platforms. The graphical interface portions can be compiled using either standard X Window System calls or the IRIS Graphics Library. It can also be compiled for multithreading support on Sun and SGI machines. The documentation includes a tutorial and a Cellang reference manual, both of which are available in LaTeX format.
[http://www.cs.runet.edu/~dana/ca/cellular.html]
Cephes: A software library of more than 400 high quality mathematical routines for scientific and engineering applications, all written entirely in C. Many are supplied in six different arithmetic precisions, i.e. 32-bit single, 64-bit IEEE double, 64-bit DEC, 80- or 96-bit IEEE long double, and extended precision formats having 144-bit and 336-bit significands. About 180 different mathematical functions are covered, including elementary arithmetic and transcendental routines, probability integrals, Bessel functions, and higher transcendental functions. There are complex variable routines covering complex arithmetic, logarithms and exponentials, and trigonometric functions. A simple, common error handling routine is supplied with error conditions producing a display of function name and error type.
Several source code distributions of Cephes are available in the various precisions described above. Each distribution contains the basic routines as well as some example applications written with them. They are all written in C and documented via man pages included in each distribution package. The primary documentation for the functions is Moshier (1989).
[http://www.netlib.org/cephes/index.html]
[http://sunsite.unc.edu/pub/Linux/devel/lang/c/]
CEPS: The Cisco Enterprise Print System is a collection of tools and utilities designed to work together to create a highly scalable, robust printing environment for a medium to large corporation. The tools are designed to optimize the management of large numbers of printers, so the package wouldn't be terribly useful for a single person.
The features of CEPS include:

automatic creation of a printer record, spool directories, and a default name upon initial printer bootup;

automatic printer record updates when a printer is moved to a different subnet;

automatic changes in the DNS database when a printer is created, deleted or renamed;

automatic load balancing among print servers;

automatic installation of print drivers;

printer access over TCP/IP via either port 9100, LPR or reverse Telnet; and

support for homogeneous networks.

[http://ceps.sourceforge.net/index.shtml]
Cerberus: A prototype package containing reference implementations of emerging network layer Internet security or IPsec technologies. This Linux kernel module provides complete support for IPsec authentication and encryption services in both tunnel (i.e. firewall) and transport (i.e. host) modes. The code architecture consists of four main components:

the Security Association database (SADB) management routines which process database requests from user space via a Linux netlink socket;

the IPsec protocol engine, i.e. a set of functions that process in- and out-bound ESP and AH requests as well as perform some simple policy checks;

the cryptographic transforms and algorithms which together are used to encrypt and decrypt data as well as generate and verify authentication data;

the interface to IP.

A source code distribution of Cerberus can be obtained on a floppy disk after completing and returning a distribution form to satisfy ITAR export control regulations.
[http://www.antd.nist.gov/itg/cerberus/]
cfengine: A scripting language designed for testing and configuring heterogeneous UNIX-like systems attached to at TCP/IP network. Cfengine is the result of a research project to help solve the problems of system administration in a big network. Its main purpose is to allow the creation in an intuitive way of a single, central system configuration file which will define how every host on a network should be configured. It runs on every host and parses one file (or a set of files) with the configuration of the host checked against the file. The sysadmin is either warned about any deviations or they are automatically fixed.
Cfengine follows a flexible class-based decision structure which allows a specific group of hosts to be singled out with a single statement. It focuses on tasks that are difficult to handle with scripts of various types. The tasks that can be automated with cfengine include:

checking and configuring the network interface,

editing text files,

making and maintaining symbolic links including multiple links from a single command,

checking and setting the permissions and ownerships of files,

deleting junk files,

systematic and automated mounting of NFS systems,

checking for the presence of important files and file systems,

controlled execution of user scripts and shell commands, and

process management.

A source code distribution of cfengine is available. It is written in C and can be compiled and installed on a variety of UNIX flavors via the supplied configure script. It is documented in a user's manual available in PostScript format.
[http://www.iu.hioslo.no/cfengine/]
[http://www.gnu.ai.mit.edu/order/ftp.html]
cfortran: A package for creating an easy-to-use and machine independent interface between C and Fortran routines and global data. This allows Fortran routines and global data to be used from C just as easily as from Fortran, and C routines and global data to be used from Fortran as easily as from C. The interfaces can be created with little or no knowledge of machine or compiler or OS details, requiring only a description of the global data and of the arguments and routine values of the routines. This description is passed as arguments to C preprocessor directives as defined in a cfortran.h file, a process that generates the code needed for the interface.
A source code distribution is available consisting of an ASCII documentation file, the engine in cfortran.h, and example files cfortest.c and cfortest.for containing examples of the use of the package.
[http://zedy00.desy.de/~burow/cfortran/]
C4: The Canonical Classes for Concurrency Control is a library of C++ classes which assist in parallel programming. C4 allows the programmer to express parallel programs using high level abstractions for a variety of useful operations. Object classes are provided which implement a variety of synchronization and data transmission paradigms. With these classes some important communication patterns can be handled via C++ objects rather than by having to explicitly code every single interaction between processing nodes with message passing calls. C4 will work on either a multicomputer or a network of workstations running either MPI or NXLib.
The C4 package is built on top of and therefore requires the use of the DS++ library package. It can be compiled using either Cfront or g++. It is documented in a FAQ and man pages included with the distribution.
[http://dino.ph.utexas.edu/~furnish/c4/c4.html]
C4.5: A program for inducing classification rules in the form of decision trees from a set of examples. The system consists of four principal programs:

c4.5, the decision tree generator;

c.4.5rules, the production rule generator;

consult, the decision tree interpreter; and

consultr, the production rule interpreter.

See Quinlan (1992).
[http://www.cse.unsw.edu.au/~quinlan/]
CFS-C: A package of subroutines and data structures which can be used to implement learning classifier systems for arbitrary, user-defined task domains or environments. The CFS-C routines implement the core, domain-independent parts of a classifier system including routines to implement the steps of the cycle of a classifier system: comparing messages to classifiers and record all matches; calculate bids, run a competition, generate new messages by activating the winning classifiers; and apply the bucket-brigate algorithm, a learning mechanism that redistributes strength to classifiers which tend to lead to useful system behavior. The package also includes subroutines which implement learning algorithms that discover new and potentially useful classifiers, e.g. genetic algorithms. A simple, well-defined interface between the core classifier system and the domain-dependent parts of the system is provided.
The CFS-C package includes subroutines which implement a command processor which acts as an interface between a user and the system. It provides ways to: run the major cycle of the classifier; load messages and classifiers from files into the system's message and classifier lists; display the contents of the message and classifier lists; display and set the values of various system parameters; produce a log of a session; save the complete state of the system in a file; and restart the system from a saved state file. CFS-C is not a standalone program that can be run but rather a package of subroutines which must be linked to the subroutines and data structures which implement a specific task or environment. Two such environments are included in the CFS-C distribution: LETSEQ, a system that involves learning to predict letter sequences; and FSW, a system that involves learning to traverse a finite state world.
A source code distribution of CFS-C is available. It is written in ANSI C to be portable to a wide variety of systems, including UNIX platforms. Documentation is available for the CFS-C package as well as the included LETSEQ and FSW programs in TeX DVI format.
[ftp://ftp.cs.wayne.edu/pub/EC/CFS/src/]
CFS-C XV: An updated and extended version of CFS-C.
[ftp://ftp.cs.wayne.edu/pub/EC/CFS/src/]
CG: The Conjugate Gradient package is a library of iterative solution methods for linear systems of equations on distributed processors connected via the PVM library. The iterative methods available in CG include conjugate gradient (CG), CG on normal equations, minimum residual, bi-CG, quasi-minimum residual, non-symmetric CG, generalized minimum residual (GMRES), CG squared, and bi-CG stabilized.
A source code distribution of CG is available. It is written in C and is configured to compile and install on most UNIX flavors to which PVM has been ported. A graphical interface created using Tcl/Tk is included along with a stand-alone demo program. The CG library links with some LAPACK and BLAS routines which are included in the distribution.
[http://www.netlib.org/linalg/]
CGAP: The Channel Geometry Analysis Program permits the analysis, interpretation, and quantification of the physical properties of an open channel reach as defined by a sequence of cross-sections. CGAP primarily computes the area, width, wetted perimeter, and hydraulic radius of cross-sections at successive increments of water surface elevation (i.e. stage) from data consisting of coordinate pairs of cross-channel distances and land surface or channel bottom elevations. Also computed are longitudinal rates of change of cross-sectional properties as well as the mean properties (including discharge as computed using the Manning's equation) of a channel reach and the cross-sectional area and channel widths as functions of stage for subdivisions of a cross-section. CGAP was developed to compute, display, and format cross-sectional data for use with simulation models, especially for BRANCH and HSPF.
A source code distribution of CGAP for UNIX platforms is available. The primary documentation is contained within Regan and Schaffranek (1985). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/cgap.html]
[http://www.geogr.uni-jena.de/software/cgap.html]
CGI: The Common Gateway Interface is a standard for interfacing external applications with information servers, e.g. HTTP or Web servers. While a plain HTML document is static, a CGI program is executed in real-time and can output dynamic information. CGI programs are usually written in C, C++, Perl, Tcl/Tk, Python, or in any number of less common languages. They can be binary executables (as is usually the case with C or C++) or scripts which invoke interpreters for scripting languages (the case with Perl, Tcl/Tk, and Python).
CGI related libraries and programs include:

cgic

Cgicc

cgi-draw

cgihtml

cgi-lib.pl

CGIperl

cgi.tcl

cgi-util

CGIWrap

jmtk-cgi

Le Sursis, a project to develop CGI programming in Common Lisp;

libcgi++

libHTML

Libwww

See also FastCGI and CGIWrap. See Deep (1996), Gundavaram (1996), Boutell (1996), Brenner and Aoki (1996) and Maggiano (2000).
[http://www.cgi-resources.com/]
[http://www.itm.com/cgicollection/]
[http://www.extropia.com/Scripts/]
[http://hoohoo.ncsa.uiuc.edu/]
cgic: An library of ANSI C routines for CGI programming. The cgic library can perform such tasks as:

parsing form data and correcting for defective and/or inconsistent browsers;

transparently accepting both GET and POST form data;

handling line breaks in form fields in a consistent manner;

providing string, integer, floating-point, and single- and multiple-choice functions to retrieve form data;

providing bounds checking for numeric fields;

loading CGI enviroment variables into C strings which are always non-null;

providing a way to capture CGI situations for replay in a debugging environment; and

providing a safer form of the system() function.

The cgic distribution contains the source code, written in ANSI C, and should compile on any compatible compiler, e.g. gcc. Each function is documented online and in documentation provided in the distribution.
[http://www.boutell.com/cgic/]
Cgicc: A C++ class library for writing CGI applications. The capabilities of Cgicc include:

transparently parsing both GET and POST form data;

providing string, integer, floating point and single- and multiple-choice retrieval methods for form data;

providing methods for saving and restoring CGI environments to aid in application debugging;

full on-the-fly HTML generation capabilities with support for cookies and file inclusion; and

HTTP file uploading.

A source code distribution of this C++ library is available.
[http://www.gnu.org/software/cgicc/cgicc.html]
cgi-draw: A C library that provides bitmap manipulation routines for C programs whose main purpose is for the creation of on-the-fly graphics for Web pages. The features of cgi-draw include:

fast line drawing routines with variable thickness, point transparency and blurring;

text drawing using any available proportional font with other 30 font face/size combinations currently available;

use of nearly any bitmap file format (via the Pbmplus utilities) with copying and pasting between images, flipping/mirroring, resizing, rotation, trimming and color reduction;

graphics effects including masks, sharpening, blurring and motion blurring;

color and brightness effects including brightening and darkening, greyscale conversion and saturation; and

artistic effects including pointilist and embossing filters.

A source code version of this C library is available.
[http://www.sonic.net/~nbs/unix/www/cgi-draw/]
cgihtml: A collection of routines for parsing Web CGI input and producing HTML. This C library is available in source code format.
[http://www.eekim.com/software/cgihtml/]
cgi-lib.pl: A library for creating CGI scripts in Perl.
[http://cgi-lib.stanford.edu/cgi-lib/]
CGIperl: A Perl 5 module set for performing CGI programming. CGIperl includes modules for managing the interface between the application and an HTTP daemon (CGI::Base), handling MIME-type multipart form data (CGI::BasePlus), writing to the HTTP error log (CGI::Carp), building smart HTML forms (CGI::Form), adding the ability to become a mini HTTP server to the Base module (CGI::MiniSvr), and parsing client requests via a CGI interface (CGI::Request).
The distribution (which can also be obtained at all CPAN sites and mirrors, is written in Perl 5. Documentation is available in HTML format.
[http://www-genome.wi.mit.edu/WWW/tools/scripting/CGIperl/]
CGI++: A tool for writing CGI/database applications in C++. It preprocesses C++ source code with embedded CGI++ macros and generates compilable C++ code. It can also process HTML with embedded C++ variables and generate form-parsing clases with appropriate constructors. This currently (5/99) supports only MySQL. The available macro directives include:

HTML_START and HTML_END, in between which C++ variables can be incorporated;

MAIN_START and MAIN_END, embeds main() and writes code to send to the HTTP header;

SQL_DB_DRIVER, specifies which database driver to use;

SQL_DECL_DBH, declares a global variable to be used for a connection handle;

SQL_ON_ERROR, specified what to do when a database call fails;

SQL_CONNECT and SQL_DISCONNECT, open and close a database connection;

SQL_DO, executes a database query;

SQL_CURSOR_DO and SQL_CURSOR_DONE, execute a query and process the results in a loop;

MAIL_INIT and MAIL_CLOSE, start and end an email session by opening and closing a mail pipe;

MAIL_START and MAIL_END, enclose material to be sent to an open mail pipe;

MAIL_ON_ERROR, specifies a function to call if mail operations fail; and

MAIL_APP, specifies an application to be invoked on the other end of the mail pipe.

More functionality is planned.
[http://www.sashanet.com/internet/download.html]
cgi.tcl: A CGI support library for Tcl programmers. It supports forms, tables, cookies, file upload, plug-ins, JavaScript, Netscape extensions and much more. It can also be used for generating static HTML, e.g. by storing a link as a Tcl variable for updating several pages simultaneously.
[http://expect.nist.gov/cgi.tcl/]
cgi-util: A CGI interface for C programs that provides form field searching and various conversions. A source code distribution is available.
[http://www.newbreedsoftware.com/cgi-util/]

cgi-util++

A C++ wrapper for the cgi-util library.
[http://www.newbreedsoftware.com/cgi-util/]
CGIWrap: A gateway program which allows general users to use CGI scripts and HTML forms without compromising the security of the HTTP server. Scripts are run with the permissions of the user who owns the script, and several security checks are performed on the script which will not be executed if any checks fail. CGIWrap is used via a URL in an HTML document. It is written in C and installation is made easier via the inclusion of a configuration script with the distribution.
[http://www.umr.edu/~cgiwrap/]
CGM: The Computer Graphics Metafile is a machine and operating system independent interchange format which provides elements to represent geometric and raster graphics. It is primarily intended for vector-based images but can also be used with raster-based images. CGM is a static picture-capture metafile standard, i.e. it contains no functions with dynamic effects on partially defined pictures. It consists of a functional specification and multiple encodings for different purposes. The three standard encodings for CGM are clear-text, character, and binary. The first is readable ASCII, the second compacted ASCII, and the third binary.
[http://www.cgmopen.org/]
[http://www.itl.nist.gov/div897/ctg/graphics/cgm.htm]

CGM Test Suite

A test suite used to determine the degree to which a CGM interpreter implementation conforms to the CGM standard (i.e. ISO 8632) and the ATA CGM profile. It contains approximately 250 test file (CGMs), evaluation criteria in the form of operator scripts, and reference pictures (i.e. GIF representations of the expected picture).
[http://www.itl.nist.gov/div897/ctg/cgm_form.htm]
CGNS: The CFD General Notation System consists of a collection of conventions and a software implementation thereof for the storage and retrieval of computational fluid dynamics (CFD) data. The system consists of a standard format for recording data and software for reading, writing and modifying data in that format. The data are stored in a compact, binary format and accessible via a complete and extensible library of functions accessible via C, C++ and Fortran 77/90. A source code distribution of the library is available as is documentation in the usual formats.
[http://www.cgns.org/]
cGOP: An efficient implementation of rigorous global optimization algorithms designed to solve a class of nonconvex nonlinear problems. It is designed as a library of subroutines written in C that can be called from any high level programming langauge, and requires a local optimization package for the solution of linear, convex and mixed-integer linear subproblems (with MINOS and CPLEX being the two libraries it can currently use).
The primary methods used in cGOP are the GOP and GOP/MILP algorithms for optimizing non-convex problems, with the former being a primal-relaxed dual decomposition method that solves the original problem via a series of linear/convex subproblems, and the latter a variant that implicitly solves the subproblems using a mixed-integer linear programming formulation. Both algorithms are implemented using a branch and bound framework, where a primal problem is solved at each node of the branch and bound tree to provide an upper bound on the global solution. This solution is used to construct a Lagrange function, and the gradients of the Lagrange function are used as a basis for partitioning the problem domain into subdomains.
[ftp://titan.princeton.edu/pub/cGOP/]
CH: An interpreter which implements a superset of C. CH is a very-high level language (VHLL) that can be used for shell programming, CGI programming, distributed network computing, scientific computing, the real-time control of mechatronic systems, and as a general scripting language. The shell environment can be used in regular, restricted, and safe modes. The restricted mode disallows actions such as redirecting output, changing directories, etc., with the safe mode additionally disallowing the declaration of pointers, the casting of pointer types, etc.
CH retains most of the C features needed for scientific computing as well as some handy extensions. Metanumbers are available to represent Inf, -Inf, NaN, -0.0 and 0.0, allowing the use of the IEEE-754 arithmetic standard, and they are extended to commonly used mathematical functions. The capabilities of bitwise, assignment, address and indirection, increment and decrement, and type conversion operations are extended from what is available in ANSI C. The Common Gateway Interface (CGI) and Common Client Interface (CCI) are both implemented in the CH language and available in the distribution. CH can be used for distributed computing across the Web. Remotely located programs, i.e. applets, can be downloaded from a server and executed a the client or host computer. Secure features have been built into the language to protect a system from attack, e.g. the C pointer declaration is disabled for applets obtained under a safe shell.
Binary distributions of the CH package are available for several UNIX flavors including Linux Intel. The package includes the three shells under which CH can be run, the CGI and CCI implementations, and many examples of its use. Documentation includes a user's manual, several technical reports, and a set of man pages.
[http://iel.ucdavis.edu/CH/]
Chaos Analyzer: A suite of programs and a graphical interface for performing various tasks in chaos analysis including:

time series embedding;

mutual information;

singular value decomposition embedding;

Lyapunov exponents (full spectrum with noise robustness);

Poincare sections; and

local singular value decomposition analysis.

[http://www.ee.ed.ac.uk/~mb/analysis_progs.html]
Chaos Classes: A collection of C++ classes for use in the study of dynamical systems. These are divided into four major categories. The descriptive classes include:

CGenericMap, a superclass for all maps; and

CScatterMap, a superclass for transiently chaotic systems (derived from CGenericMap).

The analysis classes include:

CLyapunov, a superclass for Lyapunov exponent routines;

CLyapunovQR, for finding Lyapunov exponents using a QR decomposition of the differential of the map at each iteration; and

CTau, for finding the average escape time for a scattering system.

The straddle routines include:

CSST, for creating a saddle saddle trajectory from a CScatterMap.

The support classes include:

CIntegrate, a superclass for all integrators;

CRK2L, a Runge-Kutta 2nd-order integrator for symplectic systems;

CRK4, a Runge-Kutta 4th-order integrator;

CRK4a, a Runge-Kutta 4th-order integrator with adaptive step size; and

CRK4C, a Runge-Kutta 4th-order integrator for symplectic systems.

A source code distribution is available.
[http://www.glue.umd.edu/~dsweet/ChaosClasses/]
CHAOS: A C++ runtime library for parallelizing Fortran and C programs with irregular data access patterns. The CHAOS library is a set of software primitives designed to efficiently handle irregular problems on distributed memory systems. The primitives are designed to ease the implementation of parallel problems on parallel machines by relieving users from the specification of low-level machine specific issues. A source code distribution is available which supports several parallel machines as well as networks of workstations connected via PVM.
[http://www.cs.umd.edu/projects/hpsl/ AdditionalInformation/compiler/ChaosLibrary.htm]
CHARM: A machine independent parallel programming system which allows programs written using it to run unmodified on MIMD machines with or without a shared memory. CHARM provides high-level mechanisms and strategies to facilitate the task of developing highly complex parallel applications. CHARM programs are written in C with some syntactical extensions. It is also possible to interface to other languages such as Fortran using the language interfaces provided. Charm++ is a C++-based parallel object-oriented language with all the features of CHARM plus multiple inheritance, late bindings, and polymorphism.
The CHARM distribution includes Converse, a framework for interoperability across parallel languages and support for building runtime systems for new parallel languages. The capabilities of this are demonstrated via the inclusion of some other parallel languages in the distribution including: a demo language which supports multiple threads per processor and simple message passing, parallel Java, a subset of PVM, a Futures library, and a message-driven extension of Perl called mdPerl. Tools included in the distribution include: DagTool, which allows the specification of dependencies between messages and sub-computations within a single process to provide a pictorial view of the dependence graph; Projections, a performance visualization and feedback tool; and SummaryTool, a simple performance analysis tool.
Binary distributions of the CHARM system are available for several platforms including Linux Intel. Programs written on any platform are portable to any other platform. Documentation is available in PostScript format for each part of the CHARM system.
[http://charm.cs.uiuc.edu/]
Charon: A distributed filesystem that is thus far (9/99) no more substantial than a teaser on Slashdot. It is supposed to be a true 64-bit, journaled filesystem that supports:

exabyte-plus file and volume sizes;

sophisticated access control lists;

per-directory quotas;

distributed zero-knowledge protocol authentication;

encryption;

replication; and

named streams and indices.

As of the time of the announcement, it is is beta test stage.
[http://slashdot.org/askslashdot/99/09/18/2237232.shtml]
Chautauqua: An experimental workflow system whose design focuses on dynamic change and exception handling. Chautauqua is implemented as a client/server application using the Python-based Paos package.
[http://www.cs.colorado.edu/~carlosm/chautauqua.html]
Checkbot: A tool for verifying links on a set of HTML pages. It can check a set of documents on a single server or on a set of servers. It creates a report which summarizes all links which prompt either an error or warning message. This is written in Perl and requires version 5.002 and the libwww-perl package.
[http://dutifp.twi.tudelft.nl:8000/checkbot/]
Checker: A GNU tool which finds memory errors at runtime. The primary function of Checker is to emit a warning when the program reads an unitialized variable or memory area or when it accesses an unallocated memory area. It has a Malloc library that issues warnings when free or realloc is called with a pointer that hasn't been obtained from malloc, calloc or realloc, or when free or realloc is called with a pointer that has been previously freed. Checker also implements a garbage detector that can be called either in your program, by a debugger, or on exit from the program. The garbage detector displays all the memory leaks along with the functions that called malloc.
A source code distribution of Checker is available. It can be installed via the usual GNU tools. The documentation is also available in the usual GNU format.
[http://www.gnu.org/software/checker/checker.html]
check-ps: A program designed to detect rootkit versions of ps that fail to detect selected processes. Rootkits are programs installed by script kiddies that allow them to abuse machines undetected, and many also contain various kinds of backdoors. The program understands the Linux /proc format and detects various information about hidden and other processes including:

the process id, parent process id, process group, and session process id;

the device and inode of all fds and if the fd is a socket it will provide information about both ends; and

the command name and arguments.

It works by generating its own pid list and comparing it to the output of ps. A source code distribution is available.
[http://checkps.alcom.co.uk/]
chemistry: Packages related to non-organic chemistry, chemicals and/or chemical engineering include:

ASCEND, a mathematical modeling environment originally developed for chemical engineers;

BALNINPT, for quantifying chemical reactions between groundwater and various minerals and gases;

CACTVS, a system for the computation, management, analysis and visualization of chemical information;

Chemsuite, a set of programs for performing calculations in chemistry,

chemsym, for typesetting chemical symbols;

CML, an extension of SGML for chemical information;

HSPF, for simulating hydrologic and water quality processes;

LARKIN, for simulating large systems involving chemical reaction kinetics;

MAP, a library of programs for calculating the properties of steel, nickel and crystals;

MOPAC, a molecular orbital package for the study of chemical structures and reactions;

MPQC, for computing the properties of molecules;

NETPATH, for calculating geochemical mass balance reactions in hydrology;

NWChem, a computational chemistry package;

OmSim, a general simulation environment that has been used to model chemical processes;

PHREEQC, for performing a wide variety of aqueous geochemical calculations;

PHRQPITZ, for calculating geochemical reactions in brines and other highly concentrated electrolyte solutions;

SOLVATE, for constructing atomic solvent models for given solutes;

STERIC, for calculating molecular steric parameters for organometallic and crystal chemistry; and

Viewmol, for viewing the output of quantum mechanical and molecular modeling programs.
Chemsuite: A set of programs for performing various calculations useful to chemists. This is mostly a gleam in the milkman's eye as yet (4/00) although the planned components (the first of which is apparently ready to go) include:

MolCalc, a molecular weight calculator;

Chem2D, a 2-D molecular designer;

ChemChroma, a chromatography simulator;

ChemNMR, an NMR reader and simulator;

ChemMC, a Monte Carlo integrator, reader and simulator; and

ChemModel3D, a 3-D modeling package and reader for large molecules.

[http://chemsuite.seul.org/]
Cheney-Kincaid: A series of example Fortran programs from a textbook on numerical mathematics, i.e. Cheney and Kincaid (1985). The algorithms/topics implemented in these programs include the bisection method, Newton's method, Simpson's rule, Gaussian elimination, tridiagonal and pentadiagonal solvers, cublic splines, Euler's method, Runge-Kutta-(Fehlberg) methods, random numbers, Monte Carlo methods, Adams-Moulton method, shooting methods, Crank-Nicholson method, Gauss-Seidel method, and several more.Monte Carlo methods, Adams-Moulton method, shooting methods, Crank-Nicholson method, Gauss-Seidel method, and several more. The codes are deliberately uncommented to force the user to study the code and the book.
[http://www.netlib.org/cheney-kincaid/index.html]
Cheops: A network user interface designed to be the network equivalent of a swiss army knife, i.e. to unify all network utilities in one tool. Cheops aims to provide administrators and users with a tool for locating, accessing, diagnosing and managing network resources with the click of a button. The features of the current (12/98) version of Cheops include:

organizing a network into multiple pages so relevant portions can be combined;

detection of the OS of hosts on a network with appropriate icons for most if not all;

quickly locating hosts on large networks;

drawing maps of the routes taken to access areas of a network to more clearly show the network hierarchy;

clicking on a host to access a menu of common network services on that host and using those services; and

multiple views of large networks with smaller/larger/no icons and arrangement by domain, hostname, IP address, etc.;

A source code distribution is available as are binaries for Linux. Compilation requires GTK 1.0 or 1.1. This is being designed for integration into GNOME and is available under the GPL.
[http://www.marko.net/cheops/]
Chicory: A rapid application development environment for Java. The developers mention that a version of this will eventually (8/98) be available for Linux, although it is not yet.
[http://www.cerc.wvu.edu/chicory/]
CHIMP: An implementation of MPI developed at the Edinburgh Parallel Computing Center. This one is a bit dated since the last update was in 1995.
[ftp://ftp.epcc.ed.ac.uk/pub/chimp/release/]
Chipmunk: A collection of tools for performing a wide variety of tasks including electronic circuit simulation and schematic capture, graphics editing, and curve plotting. The major Chipmunk tools include:

Log, a circuit schematic capture tool and simulation environment;

View, a data manipulation and plotting tool;

Until, a graphics editor for generating publication-quality graphics; and

Wol, a graphical environment for IC mask layout.

A series of supplementary programs are for converting Chipmunk format files to and from other popular formats. A source code distribution is available and has been compiled on several platforms including Linux Intel. Documentation is scattered about in various packages in various formats.
[http://www.pcmp.caltech.edu/chipmunk/]
chklogs: A set of Perl scripts that perform maintenance on all registered system logs. A configuration file contains the location of each log file, the maximum size or age it should be allowed to reach before being processed, and the preferred action that should be taken on the file. A source code distribution is available.
[http://www.iaehv.nl/users/grimaldo/chklogs.shtml]
Choices: An object-oriented operating system written using C++. The architecture of Choices is organized into frameworks of objects hierarchically classified according to function and performance, and the OS is customized by replacing subframeworks and objects. The application interface is a collection of kernel objects exported through the application/kernel protection layer. Choice will run on several architectures including Intel x86. A simulator that runs on UNIX machines is also available. Choice distributions are freely available upon obtaining a release via an email address at the site. Quite a bit of documentation is available.
[http://choices.cs.uiuc.edu/choices/]
Choose-OS: This is a boot loader for Linux/x86 intended as a replacement for LILO. It is loaded by the BIOS before an OS and allows an OS to be chosen for booting. The current (5/99) features include:

loading the Linux kernel and bootsectors of other operating systems;

implementation of operating system loaders as modules;

MBR rewrite in the bootsector loader;

single-shot autoboot in which the OS desired for the next boot can be specified;

loading an emergency boot sector when the expected boot data can't be loaded; and

a graphical configuration utility.

[http://www.students.tut.fi/~tuomov/chos/]
Chorale Toolbox: A software toolbox for numerical analysis and simulation that interfaces with both Matlab and (soon, according to the site) Octave. Chorale is broken into several categories of tools, with each containing one of more related programs. These include:

console, console interface tools for displaying lines, variables, prompting user input, etc.;

control, control system design tools for computing transfer functions, step responses, etc.;

elfun, elementary math functions;

elmat, elementary matrix manipulation functions;

general, general purpose commands for copying files, installing packages, etc.;

graphics, functions for handling graphics;

ident, system identification functions;

interp, interpolation and polynomial functions;

signal, signal processing functions for finding beat frequencies, envelopes, calculating wavelets, smoothing data, etc.;

simulink, simulink blockset functions; and

strfun, functions for handling character strings.

[http://matlinks.net/chorale.html]
CHPP: The CHakotay PreProcessor is a preprocessor originally designed for HTML which can be applies to nearly any use. CHPP combines the features of cpp, m4, Perl, and Scheme and, according to the authors, is still fairly simple. The features include:

it is non-intrusive, i.e. you can take existing text, pipe it through CHPP, and it probably won't change it;

user-defined macros which can be recursive;

complex data structures such as lists and hashes;

regular expression matching; and

powerful loop constructs.

A source code distribution of CHPP is available. It is written to be portable and should compile and run on almost any UNIX platform. A reference manual is available.
[http://www.unix.cslab.tuwien.ac.at/~chpp/]
chrony: A package for maintaining the accuracy of the system clock on a computer. This consists of two programs:

chronyd, a daemon that keeps track of the time in various ways; and

chronyc, an interface for monitoring chronyd and configuring various settings.

This can be used to keep a computer clock in step with the true time (i.e. UTC) and also to keep a network of computers in time with one another. Several reference modes are available including:

an NTP server with chronyd capable of acting as an NTP server;

a wristwatch or some other clock if keeping several computers synchronized with each other rather than truly accurate is the goal;

a hardware reference clock such as a GPS or radio clock receiver connected to the computer; and

the system's real-time clock (i.e. the one that maintains the time when the computer is turned off).

Chrony also works well with a dial-up connection to an NTP server - both in intermittent and permanent connection model. A source code distribution is available.
[http://www.rrbcurnow.freeserve.co.uk/chrony/]
CHSM: A simple and expression programming language for coding Statecharts that extends C++ to support reactive system implementations. It is used to implement concurrent, hierarchical finite-state machines. A source code distribution is available. It is written in C++ and also requires an STL implementation for compilation.
[http://www.best.com/~pjl/software.html]
CIAO: A next generation, public domain PROLOG system which supports the development and efficient compilation of logic programs, constraint logic programs (CLP), functional logic programs and object-oriented logic programs. CIAO includes standard ISO-Prolog as a subset and a program development environment. It has been designed from the ground up to allow modular program development, global program analysis, and static debugging and optimization via source to source program transformation including automatic parallelization.
CIAO additionally extends the PROLOG language and improves on standard programming environments in several ways including:

support for programming in the large with a robust module/object system, module-based automatic incremental compilation, an assertion language for declaring program properties, automatic static inference and static/dynamic checking of the assertions, etc.;

support for programming in the small via production of small executables and support for scripting;

a CIAO compiler that generates several forms of architecture-independent and standalone executables with library modules that can be compiled into compact bytecode or C source files and linked statically, dynamically or autoloaded;

support for concurrency via threads, distributed execution, and parallel execution; and

a large number of libraries providing a wide range of additional functionality from Web programming to support for several control rules.

The CIAO is distributed under the GPL. Instructions for obtaining it can be obtained via an email message to an address given at the site.
[http://www.clip.dia.fi.upm.es/Software/]
Ciber Tienda: A virtual shopping system released under the GPL. This combines with Apache and Open-SSL to be the first (2/00) open source business solution. It is currently being moved from a non-open source development system to an open source system. It supports only PostgreSQL as a database backend, but support for MySQL plus several commercial database systems is planned.
[http://www.cibertienda.org/]
CICE: The Los Alamos Sea Ice Model (get it?) is the result of an effort to develop a computationally efficient sea ice component for a fully coupled atmosphere/ice/ocean/land global climate model. It was designed to be compatible with the POP ocean circulation model. CICE consists of three major components:

a thermodynamic model that produces local growth rates of snow and ice due to local conductive fluxes, snowfall and local temperatures;

an ice dynamics model that predicts the velocity field of the ice pack based on a model of the material strength of the ice; and

a transport model which describes advection of the areal concentration, ice thicknesses and other state variables as well as conversions among them.

Other routines prepare and execute data exchanges with an external flux coupler that passes the data to other climate model components.
[http://www.acl.lanl.gov/eclare/cicecode/cice.html]
Cicero: A word processor with a font installer that installs PostScript Level 1 fonts in X, ghostscript, TeX and Cicero native format. It is written in C++ and runs on UNIX/X Window systems, and also requires Motif. 2.0. The sources are available as well as a statically linked binary. There is no documentation as yet but it is said to be "on the way".
[http://zeus.informatik.uni-frankfurt.de/~weis/cicero.html]
CIDLib: A C++ development framework whose purposes are to:

encapsulate the services of the host operating system to make them more object-oriented, safer, convenient and portable; and

provide a large scale set of object services that are stylistically and architecturally consistent, powerful and highly integrated.

This permits CIDLib to provide a set of core development services which are more portable than either the C++ runtime libraries or the host system services, as well as safer and more convenient.
The functionality provided by CIDLib includes:

the implementation of a `virtual kernel' layer, outside which no host or RTL headers are used, allowing all CIDLib and client code to use a high level of error reporting during compilations without the need for the non-ANSI C++ compliant compiler extensions required for direct operating system or RTL access;

a CIDBuild utility providing build services that provides project dependencies, header dependency analysis, platform independent project settings, and message file compilation;

advanced RTTI including polymorphic streaming, dynamic object creation, a fully integrated runtime type information system, a type repository, and simple meta class support;

collections including bags, sorted bags, deques, queues, stacks, doubly linked lists, singly linked lists, hash maps, hash sets and object arrays that are fully templatized, typesafe, and optionally thread safe on a per-instance basis;

a range of core data types including strings, memory buffers, areas, points, sizes, colors, ranges, money, numerics, time stamps, etc.;

an encryption framework that can be extended to include other encryption and hashing algorithms;

extensive support for error and message logging and exception management;

file system support including directory iteration, general file system maintenance, find buffers, smart path strings, binary files, text files, etc.;

streams that are abstracted from the actual data source via implementation objects so they can be extended to use many different data sources;

internationalization support via a C++ orieinted message compiler that is fully Unicode oriented;

locale support for localizing applications;

mathematics support including 4x4 homogeneous matrices, 2- and 3-D vectors, value maps, ranges, and core mathematical library interfaces;

process control including threads, mutexes, semaphores, events, critical sections, threadsafe counters, process information and per-thread data;

support for TCP/IP sockets with classes for stream and datagram client and server side sockets, a socket listener class, IP addresses and endpoints and URLs;

a CIDImage framework for getting graphics file formats into memory as bitmaps and getting them back out after manipulation; and

a regular expression engine.

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

CIFLIB

A C class library developed to provide an application program interface to macromolecular data in CIF format. A source code distribution is available as is a reference manual in HTML and PostScript format.
[http://www.iucr.ac.uk/iucr-top/cif/mmcif/ndb/software/CIFLIB/index.html]

Xtal_GX

A program designed primarily to read and write crystal structure information in the form of CIFs. It can be used to validate CIFs against the CIF Dictionary. In addition to parsing CIFs, it also extracts symmetry and structural information for display, manipulation and plotting purposes. Additional routines assess the structure for unrecognized symmetry elements in the structure which can also be graphically represented. Binary distributions are available for several platforms including Linux Intel. A user's guide is available in PostScript format.
[http://www.iucr.ac.uk/iucr-top/cif/software/xtal/gx/index.html]
CIFS: The Common Internet File System is a standard remote file system access protocol for use over the Internet. It is an open, cross-platform technology which is an enhanced version of Microshaft's Server Message Block (SMB) protocol, the native file-sharing protocol in the Microshaft operating systems. The chief enhancement is that CIFS runs over TCP/IP and uses the DNS for scalability. It is also optimized to support slower speed dial-up connections. It is designed to complement HTTP while providing more sophisticated file sharing and transfer than older protocols such as FTP. It is also designed to allow all applications to open and share files securely across the Internet. The Samba package implements CIFS.
[http://www.microsoft.com/workshop/networking/cifs/]
Cilk: An algorithmic multithreaded language whose philosophy is that the programmer should concentrate on structuring his program to expose parallelism and exploit locality and leave the runtime system with the responsibility of scheduling the computation to run efficiently on a given platform. As such the Cilk runtime system handles load balancing, paging and communication protocols. It differs from other runtime languages in that its runtime system guarantees efficient and predictable performance.
The distribution contains a runtime system and the Clik2C compiler, a type-checking preprocessor that translates Cilk into C. The most recent version, 4.0, is configured for Sun Solaris SMPs (Symmetric Multi-Processors) as well as SGI SMPs, and a version for distributed memory machines (such as networks of workstations) is expected by Fall 1996. An earlier version, i.e. 2.0, is still available which already works on vanilla UNIX machine networks, including Linux. Documentation is available in the form of user's manuals for the various versions and several technical reports, all in PostScript format.
[http://supertech.lcs.mit.edu/cilk/]
cim: A compiler for the Simula language (except for unspecified parameters to formal or virtual procedures). It offers a class concept, separate compilation with full type checking, an interface to external C routines, an application package for process simulation, and a coroutine concept.
A source code distribution of cim is available. The compiler and the run-time system are written in C and the compiler produces C code that is compiled using the platform's native C compiler. A user's manual is included in several formats.
[ftp://ftp.ifi.uio.no/pub/cim/]
[http://www.ifi.uio.no/~cim/cim_toc.html]
Cineast: A browser written in an extension of Tcl/Tk called OTcl. It uses the Wafe toolkit to implement the user interface, especially the Kino widget class which provides a callback interface for HTML parsing and arbitrary widgets as insets. Cineast supports most of HTML 3.2 and also features incremental parsing and rendering. Secure connections are possible via an interface to SSLeay. A source code version is available as is a binary for Linux Intel platforms (either statically or dynamically linked to Motif).
[http://nestroy.wi-inf.uni-essen.de/wafe/Cineast/]
CINEMA: The Color INteractive Editor for Multiple Alignments is a package for the visualization and manipulation of both protein and DNA sequences. CINEMA allows the interactive building of alignments using either a free-format cut and paste facility to import sequences or by adding sequences directly from a database. Alignments are edited by clicking on a sequence and dragging it to create gaps. The functionality of the package includes:

viewing the effects of insertions or deletions made at a particular point;

using stacked hydropathy profiles as a tool to aid alignment;

manipulating sequences as groups;

selection and display of single or multiple motifs;

invoking the 3-D skeleton of a sequence;

the 6-frame translation of DNA sequences;

diagonal plots of protein sequences;

automatic alignment and database searching; and

automatic coloring of sequences according to residue type.

A source code distribution of CINEMA is available. It contains the Java classes, HTML, and Perl scripts needed to set up and maintain an installation. Extensive documentation is available in HTML format.
[http://www.biochem.ucl.ac.uk/bsm/dbbrowser/CINEMA2.1/]
CINQ: A project to create a multi-platform BASIC compiler with QuickBASIC compatibility.
[http://shell.flite.net/~rmann/]
CINT: A C/C++ interpreter aimed at processing scripts in those languages. This is intended for rapid development tasks rather than those in which execution time is critical. This is written in ANSI C and covers about 95% of ANSI C and 85% of ANSI C++. It is sufficiently solid and stable to interpret itself and let the interpreted version execute a program. This is currently used mostly in the larger ROOT system, although a source code distribution of CINT itself is available.
[http://root.cern.ch/root/Cint.html]
CIPE: A project to build encrypting IP routers. CIPE uses a lightweight protocol designed for passing encrypted packets between prearranged routers in the form of UDP packets. It isn't as flexible as IPSEC but is sufficient for the original purpose of securely connecting subnets over an insecure transit network. The current (1/99) implementation is in the form of a kernel driver for Linux.
[http://sites.inka.de/sites/bigred/devel/cipe.html]
CirclePack: A suite of programs providing a friendly user interface for the creation, manipulation, storage and display of circle packings. Source and binary distributions are available for both Linux Intel and Alpha platforms.
[http://www.math.utk.edu/~kens/]
Citadel/UX: A BBS for UNIX platforms. The features of Citadel/UX include:

dialup access;

telnet access;

text-based client software;

WebCit, which allows access through a browser via the Web;

ExpressCit, a Java client for access via the Web;

real-time messaging as well as traditional store and forward;

full multiuser chat functionality;

Internet email send and receive for all users;

gatewaying of Usenet groups; and

Cit86Net protocol support that allows tie-ins with other Citadel servers.

A source code distribution is available which requires pthreads on Linux platforms.
[http://uncnsrd.mt-kisco.ny.us/citadel/]
C-Kermit: Kermit is a file transfer protocol developed specifically for the error-free transmission of text and binary files between diverse types of computers over noisy communications links, e.g. over modems. It is also a suite of communications software programs. The Kermit protocol incorporates file group transmission, file attribute transmission, file collision options, file transfer recovery, automatic upload and download, client/server operations, uniform services on serial and network connections, and file name, record-format, and character-set conversion.
The major features of the Kermit software include:

connection establishment and maintenance for a wide variety of connection methods, e.g. dialup, TCP/IP, LAN, etc.;

terminal emulation;

error-free file transfer;

character-set translation during both terminal emulation and file transfer; and

script programming to automate complicated or repetitive tasks.

The user interface and scripting language are consistent across all supported platforms. The software is designed for robustness, i.e. is assumes that anything that can go wrong probably will go wrong. This allows it to work the first time almost every time. The reliability can be at the expense of speed, although given a good connection Kermit can be as fast as other popular protocols after a few (3) parameters have been adjusted appropriately.
The version of Kermit which works on UNIX platforms is called C-Kermit, which is available in source code format as well as in binary form for a wide range of UNIX flavors. Quite a bit of documentation is available online, but the chief documentation source is a commercially available manual whose sales provide the only source of funding for further development. See da Cruz (1997).
[http://www.columbia.edu/kermit/]
CLAIRE: A high-level functional and object-oriented programming language with advanced rule processing capabilities intended to allow programmers to express complex algorithms in a manner that is pithy, elegant, and readable. The features that enhance expressivity include:

a rich type system including type intervals and second-order types (with dual static/dynamic typing),

parametric classes and methods,

an object-oriented logic with set extensions, and

dynamic versioning which supports the easy exploration of search spaces.

Readability is enhanced by such features as:

set-based programming with an intuitive syntax,

a simple style of object-oriented programming,

truly polymorphic and parametric functional programming,

a powerful and readable extension of DATALOG to express logical conditions, and

an entity-relation approach with explicit relations, inverses, unknown values, and relational operations.

CLAIRE is a complete programming system with an interpreter, a compiler, and several tools including a tracer, a debugger, and an object inspector. It can also be used as a C++ pre-processor since it generators human-readable C++ code, and the interpreter can be used as a query langauge because of its logic and set capabilities. Additional features include a simple GUI implemented with Tcl/Tk, an Emacs mode for editing source files, and a library for solving scheduling problems.
A source code distribution of CLAIRE is available. It is written in C and can be compiled and installed on most UNIX flavors via the autoconf script provided in the distribution. The package is documented in a user's manual available in PostScript format.
[http://www.ens.fr/~laburthe/claire.html]
ClanLib: A platform-independent interface for game development. ClanLib is both a wrapper library providing a common interface to low-level libraries on various platforms, and a service-minded game SDK. The features include:

basic 2-D display of graphics and images;

basic sound support (via MikMod);

keyboard, mouse and joystick input support;

a network interface;

3-D graphics via OpenGL;

resource management;

loading images in any format supported by ImageMagick;

MPEG video playback;

font support;

scripting with Lua; and

a GUI framework.

[http://www.clanlib.org/]
classifier systems: Special types of message processing, rule-based production systems in which many rules can be simultaneously active and therefore can be processed in a parallel way. A classifier system consists of four basic parts: a classifier list consisting of a set of condition-action rules called classifiers; a message list which acts as a blackboard for communications and short term memory; an input interface which provides the classifier system with information about is environment; and an output interface which provides a way for the classifier system to communicate with or change its environment.
A classifier system is run by repeatedly executing a series of steps: add the messages generated by the input interface to the current message list; compare all messages on the message list to the condition-parts of all classifiers and record all matches for classifiers that have their condition-parts satisfied; generate new messages by activating each classifier that has its condition-part satisfied; process the new messages through the output interface; and replace the contents of the message list with the new messages; The basic classifier system has no way to learn, but this capability can be introduced by either: changing the major-cycle so that the activation of each classifier depends on some additional parameter that can be modified as a result of experience; or changing the contents of the classifier list by removing classifiers, adding new ones, or changing the conditions or action-parts of existing classifiers.
Packages which implement classifier systems are: CFS-C, CFS-C XV, and REGAL.
CLAWPACK: A collection of Fortran subroutines for solving hyperbolic systems of conservation laws in one and two space dimensions, both with and without source terms. High resolution flux-limiter finite volume methods are used on uniform rectangular grids. In two dimensions an unsplit multidimensional algorithm using transverse wave propagation has been implemented. A variety of example problems are is included in the package, which is intended both for research and instructional purposes. A nice selection of documentation in PostScript format is available. This can also be accessed at the Netlib CLAWPACK site. See also the AMRCLAW package. See LeVeque (1997 in press).
[http://www.math.washington.edu/~rjl/clawpack.html]
Clean: A general purpose, higher-order, pure and lazy functional programming language for the development of sequential, parallel, and distributed real-world applications. The design rules for Clean specify that the semantics must be based on graph rewriting systems, that it must be suitable for writing real-world applications in a compact and readable style, that programs run with an efficiency comparable to C, that direct and efficient interfacing with the non-functional world must be possible, and that a program must be fully portable.
Clean features that implement these (and other) design rules include:

semantics with which one can explicitly define the sharing of structures; strong typing including polymorphic, abstract, algebraic, and synonym types;

type classes provided to make the overloaded use of functions and operators possible;

predefined types including integers, reals, booleans, characters, strings, tuples, records, arrays, etc.;

a polymorphic uniqueness type inferencing system with which one can influence the time and space behavior of programs and efficiently interface to the non-functional world by offering direct access to file and operating systems;

a sophisticated I/O library that allows the development of window-based interactive applications; and

the possibility of dynamic process creation that can be run in parallel or interleaved.

Clean is available in binary form for Mac, MS-DOS/Windows, Linux, SunOS and Solaris systems. The distribution contains a compiler, a code generator, the I/O library, a program development system, and the documentation. The documentation consists of a language report and preliminary chapters of a forthcoming book, both available in PostScript format. See Plasmeijer and van Eekelen (1994).
[http://www.cs.kun.nl/~clean/]
CLENQT: A Fortran 77 program for reading spherical harmonic coefficients and reconstructing the gravimetric quantities contained in the World Geodetic System (WGS) 84 Earth Gravity Model. The normalized, geopotential coefficient file is complete to degree N=180 and order M=180.
[http://164.214.2.59/GandG/wgs-84/egm84.html]
ClibPDF: A library of ANSI C functions for creating PDF files from C programs without using Adobe Acrobat or related Adobe products. It can be used for both creating fast dynamic PDF Web pages in response to user input and real-time data and implementing publication-quality graph plotting. The features of ClibPDF include:

most basic drawing primitives plus arcs and circles;

plot domains with meshes for creating a graph paper appearance;

axes with flexible tick marks, numbering and labeling;

markers, pointers and error bars for data points;

generation of multi-page documents in any page order and writing interleaved pages;

support for zlib compression;

multi-level outline, i.e. bookmarks;

in-memory PDF generation with no temporary files; and

transition, timed slide show support.

A source code distribution is freely available for non-commercial use.
[http://www.fastio.com/]
CLiCC: The Common Lisp to C Compiler generates C executables from Common Lisp application programs. It is intended to be an add-on to existing Common Lisp systems for generating portable applications. It supports a subset of Common Lisp plus CLOS which is called CL_0 (i.e. CommonLisp_0) which is a strcit and very large subset of full Common Lisp + CLOS without EVAL and related constructs.
[ftp://ftp.gmd.de/GMD/apply/software/CLICC/]
Clif: A C-Like Interpreter Framework is an interpreter for preparing large programs for computer intensive information processing and for controlling technological processes. In the Clif framework syntactic and semantic structures are prepared in an open way with expressiveness similar to languages like C or Fortran. The user can then add such structures specific to a given problem to obtain a powerful application directed language.
The development of Clif was motivated similarly to the development of Matlab and similar environments, i.e. to have a convenient and open tool for the manipulation of objects in large, optimized scientific computing libraries such as BIGNUM, LAPACK, etc. The Clif structure stresses user interfaces at all levels of the interpreter system, e.g. a user can write procedures within the Clif specification, build modules in different languages, and then link those modules into Clif. The user can even add new language structures to Clif.
The Clif source code, written in C, is included with the package as well as documentation in the form of a programmer's manual and a technical report, both in PostScript format.
[ftp://dec50.vm.stuba.sk/pub/csgrp/packages/clif/]
[http://www.ifi.savba.sk/~tomas/soft.html]
[http://www.debian.org/Packages/stable/interpreters/clif.html]
CLIFFORD: A Maple V (R.4) package for Clifford algebra computations. The features include:

several basic types including Clifford polynomials and matrices, idempotent, primitive idempotent, nilpotent, generalized complex and quaternionic basis, even and odd elements, etc.;

a parser for checking input errors;

finding a real basis in a minimal ideal;

finding field elements over which spinor representations will be found;

finding bases in minimal ideals over the reals, complexes and quaternions;

finding spinor representations of both simple and semi-simple Clifford algebras in left and right minimal ideals;

creating primitive idempotents;

factoring idempotents;

using matrix representations in computations; and

working in any signature and with any bilinear form.

A source code distribution is available.
[http://www.math.tntech.edu/rafal/cliff3/]
clig: The Command Line Interpreter Generator uses a simple description to generate C code for a function which parses the command line of a typical C program. It takes as input a simple description file and generates standard C which depends only on libc. A source code distribution of clig is available. It is written in Tcl.
[http://wsd.iitb.fhg.de/~kir/clighome/]
CLiP: A literate programming tool flexible enough to be independent of programming languages and any document formatters. CLiP doesn't use explicit commands to perform the usual extraction process but rather recognizes pseudostatements written as comments in the programming language being used. It distinguishes the pseudostatements from regular comments because the former comply with a set style that can be adjusted to suit most programming languages. CLiP supports a wide range of features found in most text processing systems including the inclusion of drawings, pictures, tables, cross-references, indices, and tables of contents. It can extract any number of modules from a maximum of 64 source files and supports partially specified data types. It does not pretty print but rather copies code from the source files as-is to the module.
A source code distribution of CLiP is available. Versions are available for VAX/VMS, DOS, and UNIX platforms. A user's guide is available in PostScript format as are a wide range of examples featuring several languages and output formats.
[ftp://sun01.info.wau.nl/clip/]
[http://tug2.cs.umb.edu/ctan/tex-archive/web/clip/]
CLIPS: The C Language Integrated Production System is a development and delivery expert system which provides a complete environment for the construction of rule and/or object based expert systems. It is a language originally designed to provide support for rule-based programming which has expanded to provide support for rule-based, object-oriented, and procedural programming. It is a specialized language for expert systems which differs greatly from commonly used AI languages such as Lisp and Prolog. CLIPS has shells and utility programs specifically designed for creating expert systems. It supports a forward chaining inference technique and can also simulate a backward chaining inference method. CLIPS consists of three fundamental components:

facts, a combination of data fields which are seldom modified or changed;

rules (or knowledge), which are divided into IF (LHS) and THEN (RHS) portions and are often changed according to new facts and conditions; and

an inference engine, a cognitive processor that makes inferences by deciding which rules are satisfied by the facts.

Key features of CLIPS include:

knowledge representation using three different programming paradigms, i.e. rule-based, object-oriented and procedural;

portability to any system with an ANSI C compiler;

flexibility wherein it can be embedded as procedural code, called as a subroutine, and integrated with other languages;

extensibility via the use of several well-defined protocols;

an interactive, text-oriented development environment including debugging aids, on-line help, and an integrated editor; and

a number of features supporting the verification and validation of expert systems including support for modular design and partitioning of knowledge bases, static and dynamic constraint checking of slot values and function arguments, and semantic analysis of rule patterns to determine if inconsistencies could prevent a rule from firing or generate an error.

A source code distribution of CLIPS is available as are quite a few help ancillary packages. Documentation is extensive and includes both a reference manual and a user's guide.
[http://www.ghg.net/clips/CLIPS.html]
[ftp://ftp.cs.cmu.edu/user/ai/areas/expert/systems/clips/0.html]
[http://www.ghg.net/clips/CLIPS.html]

ClipsPerl

A package integrating CLIPS and Perl. This requires version 6.05 of the former and 5.004 or later of the latter.
[http://www.discomsys.com/~mps/dnld/]

ClipsPython

An extension module for CLIPS written in Python.
[http://starship.skyport.net/crew/gandalf/DNET/AI/]

FuzzyCLIPS

An extended version of the CLIPS rule-based shell for representing and manipulating fuzzy facts and rules. It can also deal with exact, fuzzy (or inexact), and combined reasoning, allowing fuzzy and normal terms to be freely mixed in the rules and facts of an expert system. The FuzzyCLIPS distribution includes the source code, written in C, and an 80+ page user's guide in PostScript format.
[http://ai.iit.nrc.ca/fuzzy/fuzzy.html]

JESS

The Java Expert System Shell is a clone of the core of the CLIPS expert system shell written entirely in Java. It also adds new features like multifields, multislots, and increment reset. It also includes a number of bug fixes, a more flexible user function interface, and general code cleanup and reorganization. The Java source code for JESS is available as is a rudimentary user's guide in ASCII format. It is compatible with all versions of Java starting with 1.0.2.
[http://herzberg.ca.sandia.gov/jess/]

KAPICLIPS

A set of external commands for the CLIPS expert system shell which implement the KAPI library. This was written in C for generic UNIX platforms.
[http://www.cs.umbc.edu/kqml/software/kapiclips.shtml]

wxCLIPS

A GUI extension to the CLIPS expert shell system. This is essentially CLIPS modified to work with an event-driven style of programming and a set of GUI functions. Source and binary distributions are available for Linux platforms.
[http://web.ukonline.co.uk/julian.smart/wxclips/]
CLIQUES: A project whose primary goal is to design a suite of highly secure key distribution, authentication and other auxiliary protocols for group communication. The main objective is to fill a gap in the area of secure group communication by investigating group security services, designing a family of flexible and efficient cryptographic mechanisms, realizing it in a general-purpose toolkit and demonstrating its functionality by integration with diverse group-oriented applications. CLIQUES is concerned with group-oriented security services such as:

key agreement in peer groups;

authentication;

group membership changes; and

membership non-repudiation.

The pragmatic upshot of these goals is the implementation of five different key agreement protocols, each of which requires a communications facility such as a group communication system as well as OpenSSL. Four of these can be separately downloaded, with the eventual goal being a unified toolkit.
[http://www.isi.edu/~gts/CLIQUES/]
CLISP: A Common Lisp implementation that includes an interpreter, a compiler, a subset of CLOS, and a screen editor. Additional packages running on CLISP are also available and described at the site. It runs on microcomputers (DOS, OS/2) as well as on most workstations, including Linux.
[http://clisp.cons.org/~haible/clisp.html]
CLM: Common Lisp Music is a music synthesis and signal processing package in the Music V family. It includes sound generators, various instruments, examples of note lists, a make facility for sound files, various functions useful in sound file work, and an increasingly useful graphical display capability based on the snd sound editor. The CLM instrument design language is a subset of Common Lisp including its numerical functions and nearly all of its control functions. It has been extended with a large number of sound-related functions. The instruments can be run as Common Lisp or compiled into C code.
The source code for CLM is available. It is written in Common Lisp and works on NeXTstep, SGI, Mac, Sun SunOS, and Linux Intel platforms. On the Linux platform the ACL, GLC and CLISP implementations of Common Lisp are known to work with this package. An extensive user's manual in HTML format is included in the CLM distribution. See also the snd sound editor and CMN.
[http://www-ccrma.stanford.edu/CCRMA/Software/clm/clm.html]
CLN: The Class Library for Numbers is a C++ library for performing computations with all sorts of numbers. The number classes include:

integers with unlimited precision;

rational numbers;

short, single, double and long floating point numbers;

complex numbers;

modular integers; and

univariate polynomials.

Other features of CLN include:

use of C++ for efficiency, type safety and algebraic syntax;

implementation of elementary, logical and transcendental functions;

memory efficiency via reclaiming of heap-allocated memory through an automatic, non-interruptive garbage collection;

a kernel written in assembly for various CPUs including i386;

use of superefficient low-level routines from GMP on all CPUs;

use of significantly faster Karatsuba multiplcation for large numbers; and

use of the asymptotically optimal Schonhage-Strassen multiplication algorithm for very large (more than 12,000 digits) numbers.

A source code distribution of CLN is available which requires G++ for compilation and use. An extensive user's manual is available in the usual formats.
[http://clisp.cons.org/~haible/packages-cln.html]
CloneIt: A program for helping molecular biologists find sub-cloning strategies, in-frame deletions and frameshifts using restriction enzymes and DNA polymerases. A source code distribution of this ANSI C program is available. Its use is documented online and in a technical report.
[http://locus.jouy.inra.fr/soft/cloneit/cloneit.html]
CloneSys: A tool for installing multi-boot environments that creates exact images of chosen hard disks or partitions and allows them to be copied to other machines to create identical installations. Several tools and commands (based on bash) are provided including:

clone, creates a clone on a chosen machine;

rclone, simultaneously creates clones on multiple machines;

backup, generates a backup image on the image server of a specified device;

rbackup, generates a backup image on a remote machine of a specified device;

initinstall, initializes a machine with the partitioning given in an image;

restore, restores devices on specified machines;

lockimage, locks a specified device;

unlockimage, unlocks a specified device;

state, shows all running clone or backup processes;

lastlogs, shows to last log files for specified hosts;

waitfinished, waits until all clone or backup processes have finished and sends a notification;

clonesyslog, shows a log containing all logged clone, backup, locking and unlocking operations;

mapname, remaps alias names to real host names;

clustermap, shows a map of the whole cluster;

config, shows the configuration file of a specified host; and

rex, remotely invokes clone and backup processes.

[http://www.cs.inf.ethz.ch/cops/patagonia/]
CLOS: The Common Lisp Object System is a dynamic, object oriented extension to Common Lisp that provides a general purpose programming language. The features include:

support for modules (or packages) to avoid name clashes;

a multiple inheritance scheme wherein the behavior of instance objects is defined by associated classes which can inherit functionality and state variables from multiple superior classes;

instances can have local state held by instance variables, and they can have methods (or operations) that they support;

multimethods that can dispatch based on the types of multiple arguments;

generic function calls and message passing;

a combination of methods related to function composition;

class redefinitions and updating; and

relationships between generic functions via a meta-object protocol.

[http://www.goldhill-inc.com/closys.htm]
[http://www.oopsla.snu.ac.kr/clos/clos/frame.html] [http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node260.html]
Cloudy: A Fortran package for simulating emission line regions ranging from the intergalactic medium to the broad line regions of quasars. It can be used to predict either the structure or the observed spectrum from such regions. In these regions dilute gas is heated and ionized by the radiation field of a central object. The physical conditions (i.e. the run of ionization, density and temperature) of the gas can be predicted as well as the resulting emission-line spectrum. This is done by simultaneously solving the equations of statistical and thermal equilibrium, equations that balance ionization-neutralization processes, and those for heating-cooling processes. A source code distribution of this program is available. It is written in Fortran 77 with some extensions from Fortran 90. The documentation includes an introductory guide, a guide to the numerical procedures, a programming environment guide, and a guide to comparing the output to observations. These are all available in PostScript and PDF format.
[http://www.pa.uky.edu/~gary/cloudy/]
CLP: An implementation of cu-Prolog, a symbolic and combinatorial constraint logic programming language. CLP was designed to process these kinds of restraints rather than numerical constraints since natural language processing and AI applications generally use the former. The package features a cu-Prolog interpreter written in C, support for Partially Specified Terms (PSTs) for feature structures of constraint-based grammar formalisms, and a constraint solver based on the unfold/fold transformation.
A source code distribution fo CLP is available. It is written in C and can be compiled and used on most generic UNIX platforms as well as on Mac platforms. A user's manual is available in LaTeX format. This is part of the ICOT project.
[http://www.icot.or.jp/AITEC/IFS/IFS-abst/009.html]
[http://www.icot.or.jp/AITEC/IFS/list/catalogue-E.html]
[http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/prolog/impl/clp/]
CL-PVM: A set of functions that interface Common Lisp (KCL, AKCL, or GCL) to the C-based library of PVM. This interface is complete and allows Lisp-based programs to take part in a PVM arrangement and thus facilitates the combination of symbolic and numerical mathematics, graphics, and other useful systems in a distributed manner. Documentation, on-line manual pages, and examples are included in the distribution. Both PVM and the Common Lisp distributions indicated have ports to Linux platforms.
[ftp://ftp.mcs.kent.edu/dist/wang/]
clsh: A Perl script that runs a program on a cluster of machines in parallel or sequentially, waits for the results, and displays them on the machine on which it was run. Several options are available including how many machines you want to run in parallel, timeout values, remote user IDs, and the format for displaying results. The choice of underlying methods to reach remote machines includes rsh, Kerberos-enabled rsh and ssh. A source code distribution is available which requires Perl 5.003 or above.
[http://strobe.weeg.uiowa.edu/~edhill/public/clsh/]
clusfind: A set of six programs for performing cluster analysis. The programs are: DAISY, which computes dissimilarities; PAM, which partitions a data set into clusters with a method using medoids; CLARA, for clustering large applications; FANNY, which performs fuzzy clustering; TWINS, which performs hierarchical clustering with a choice between agglomerative and divisive methods; and MONA, which performs divisive hierarchical clustering of binary data sets.
The source code for all of the programs in clusfind is available. It is written in Fortran 1977 and documented in Kaufman and Rousseeuw (1990).
[http://lib.stat.cmu.edu/general/]
Clustal: A molecular biology program for performing reliable multiple sequence alignments of many sequences. Significant newer features (for versions V and W) include:

profile alignments, i.e. alignments of old alignments;

phylogenetic trees, i.e. neighbor joining trees calculated after multiple alignment with a bootstrapping option;

better sequence input wherein several new formats are recognized;

flexible alignment output; and

a full command-line interface.

It is written in C and can be compiled on most platforms.
[ftp://ftp.bio.indiana.edu/molbio/align/clustal/]
Cluster: A program for performing cluster analysis on an arbitrary set of vectors. The cluster analysis algorithms implemented include Ward's minimum variance method, single linkage, complete linkage, group average, McQuitty's method, Gower's median method, and the centroid method. A source code distribution is available. It is written in C.
[http://www.biochem.ucl.ac.uk/~martin/programs/index.html]
CLUSTER: A library of several dozen Fortran 77 routines for performing various multivariate clustering algorithms.
The routines in CLUSTER include:

AID, which forms a tree of clusters by splitting cases on values of individual variables to minimize the sum of the squared deviations from the cluster means;

ASSIGN, which assigns each point to the cluster whose center is a minimum Euclidean distance away;

BDRAW, which outputs a bivariate block histogram;

BUILD, which builds clusters using the K-means algorithm;

CSPLIT, which finds the optimal split of variables;

DITTO, which partitions categorical data into clusters by maximizing the matches between cases in a cluster and the cluster mode;

DOT, which creates a tree of clusters of cases for categorical data by minimum-mutation fits;

FISH, which clusters a sequence of cases into subsequences using Fisher's method of exact optimization;

JOIN, which uses a general joining algorithm to form and output a tree of clusters of cases;

LETREE, which uses a leader clustering algorithm to construct a tree whose levels are determined by user-defined thresholds;

MIX, which fits a mixture model by a maximum log-likelihood criterion;

MMFIT, which finds the minimum mutation fit of a variable to a tree;

QUICK, which finds a quick partitioning of cases by comparing the Euclidean distances to the existing cluster leaders to a user-defined threshold;

RSPLIT, which finds an optimal splitting of cases;

TRDIST, which produces triads from a distance matrix;

and many other programs to perform various basic statistical and linear algebra tasks.
The programs in CLUSTER are all written in Fortran 77. There is some documentation for each program within the source code, and the codes were originally produced for Hartigan (1975). This is part of CMLIB.
[http://lib.stat.cmu.edu/cmlib/src/cluster/]
Clusters: A collection of Matlab routines to perform various clustering tasks using k-means clustering.
[http://www.cs.cmu.edu/People/dellaert/software/]
CMAT: An exact arithmetic calculator program designed to perform many of the standard arithmetical operations that can be carried out exactly (i.e. without approximations) on matrices and polynomials whose coefficients are either rational numbers, complex rational numbers, or elements of the finite field of p elements where p is a prime number less than 65536.
Several routines are available for operating on polynomials and rational, complex or mod p numbers. A great number of matrix calculation and manipulation routines are available including those for:

addition, negation, complex conjugate transpose, multiplication by a scalar, matrix multiplication and exponentiation, Kronecker product, and evaluating polynomials on a square matrix;

standard elementary row and column operations;

changing matrix entries individually or by row or column;

deleting row or column vectors;

joining two matrices by rows or columns;

creating special matrices such as the identity, elementary Jordan matrices, companion matrices and band matrices;

creating matrices whose elements are given by simple mathematical operations;

finding the inverse, adjoint, determinant, and characteristic and minimum polynomials of a matrix of scalars;

finding reduced row-echelon forms and solving linear equations;

calculating the dot product and length and using the Gram-Schmidt proess to find an orthogonal basis for the column-space;

finding the determinant and adjoint of a matrix with polynomial entries;

finding the Smith canonical form of a matrix with polynomial entries; and

printing matrices of rational numbers to a file or the screen.

A source code distribution of CMAT is available. It is written in ANSI and portable to most UNIX platforms with an appropriate compiler. Some sparse documentation is available online as well as in the distribution.
[http://www.maths.uq.edu.au/~krm/krm_cmat.html]
CMIP: The Common Management Information Protocol was a planned successor protocol to SNMP in the late 1980s. CMIP was better organized and contained more features than did SNMP, but has not become popular mainly because it runs under the OSI network communication protocol, which has itself not superseded TCP/IP as was planned. An implementation of CMIP called Webbin' CMIP is available for Linux platforms.
[http://www.inforamp.net/ kjvallil/t/snmp.html]
[http://netman.cit.buffalo.edu/index.html]
C-Mix: An automatic partial evaluator for the ISO/ANSI C language. Partial evaluation (also known as program specialization) is an automatic tool for program optimization. It performs a source-to-source staging transformation that transforms a program and partial data into a specialized and usually faster combined version by precomputing the parts of the program that depend only on the partial data. Source code and binary distributions are available, with one of the latter being for Linux Intel. A user's manual and several technical reports are available in PostScript format.
[http://www.diku.dk/research-groups/topps/activities/cmix/]
CMLIB: A collection of non-proprietary and easily transportable Fortran subroutine packages which solve a variety of mathematical and statistical problems. This was originally compiled for the National Bureau of Standards (NBS, now the NIST) and has also been called the NBS Core Math Library. Each sub-library in CMLIB is available as individual source files or as a shar archive of all the files in the sub-library. There is also a shar archive of all the other CMLIB routines required for each sub-library. The documentation is handled similarly.
The packages which comprise the library are:

ADAPT, a subroutine to integrate a user-specified function on a hyper-rectangle of dimension 2 through 20;

AMOSLIB, a collection of routines with emphasis on the special functions of statistics;

BLAS, basic linear algebra subroutines;

BOCLS, a routine to solve bounded and linearly constrained linear least squares problems;

BSPLINE/DBSPLIN, routines for computing with piecewise polynomials (B-splines);

BVSUP, a routine which solves linear two-point boundary value problems;

CDRIV/DDRIV/SDRIV, which solves initial value problems for systems of ODEs;

CLUSTER, routines for cluster analysis;

CPQR79, routines for finding all complex zeros of real or complex polynomials;

CPZERO, routines for finding all complex zeros of real or complex polynomials (which are different from CPQR79);

DEPAC, programs for solvling ODE initial value problems;

EISPACK, for solving various linear algebra problems;

FC, for solving constrained least squares problems;

FCNPACK, special function routines;

FFTPKG, routines for computing FFTs;

FNLIB, portable special function routines;

FISHPAK, for solving separable elliptic boundary value problems in 2- and 3-D;

LICEPAK, for solving various linear algebraic eigenvalue problems;

LINDRV, for solving linear systems of algebraic equations in a number of forms;

LINPACK, for analyzing various systems of linear algebraic equations (in three versions for complex, double, and single precision numbers, i.e. LINPAKC, LINPAKD, and LINPAKS);

LOTPS, programs for smooth interpolation of scattered data in 2-D;

MACHCON, routines for returning machine-dependent constants;

MXENTRP, for computing maximum entropy spectrum estimates;

NL2SN/DNL2SN, for nonlinear least squares problems;

ODRPACK, for computing a weighted orthogonal distance regression or ordinary linear or nonlinear least squares solution;

PCHIP[DS], for the interpolation of univariate data;

Q1DA, for automatically evaluating 1-D integrals;

QUADPK[DS], for definite integrals of functions of one variable;

RV, which generates random numbers or normal numbers;

DASSL/SDASSL/DDASSL, for solving systems of differential/algebraic equations (DAEs);

SGLSS, which solves over- or under-determined linear systems in the least squares sense;

SLRPACK, programs for simple linear regression;

SLVBLK, solves systems of linear equations with a coefficient matrix in almost block diagonal form;

SNLS1E, solves nonlinear least squares problems and nonlinear systems of equations;

SPLP, solves linear programming problems;

QRLSS/SQRLSS/DQRLSS, solves linear least squares problems in matrix form;

SSORT, for fast in-core sorting of arrays;

SUDSODS, for solving over- and under-determined linear equation systems;

TENSBS/DTENSBS, for interpolation of 2- and 3-D gridded data using tensor products of 1-D B-splines;

TWODQ, for the automatic evaluation of the 2-D integral of a function;

UNCMIN, for unconstrained minimization problems;

VFFT, a vectorized FFT package;

VHS3, for the vectorized solution of a 3-D Helmholtz equation on a staggered grid;

VSFFTPK, a vectorize FFT package for sequences defined on staggered grids;

XBLAS, an extended BLAS package;

XERROR, various error handling utilities; and

ZEROIN, which finds zeros of a function of one variable.

Each sub-library is described and can be obtained via its separate entry in this catalog. All the libraries are written in Fortran 77 which may possibly have some non-canonical extensions.
[ftp://ftp.nist.gov/pub/cmlib/]
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
[http://lib.stat.cmu.edu/cmlib/]
CM: Common Music is an object-oriented music composition environment which produces sound by transforming a high-level representation of music structure into a variety of control protocols for sound synthesis and display, e.g. MIDI, Csound, CLM, Music Kit, C Mix, C Music, M4C, RT, Mix and CMN. It defines an extensive library of compositional tools and provides a public interface through which the composer may easily modify and extend the system. All ports provide a text-based music composition editor called Stella.
The source code for CM is available. It is written in Common Lisp and can be compiled with ACL, GCL, CLISP, and CMUCL, all of which are available for Linux Intel platforms. The system is extensively documented in several documents in HTML format included in the distribution. The distribution site has several additional related documents. See also snd.
[http://www-ccrma.stanford.edu/CCRMA/Software/cm/cm.html]
CMAPF: A library which provides mathematical transformations of conformal maps, i.e. they perform coordinate transformations between points and vectors on the Earth's surface (given in degrees of longitude and latitude) and their equivalents on a class of X-Y grids overlaying conformal maps. The package also supplies routines which supply projection-dependent terms of the governing equations (of meteorological circulation models), wind component conversions, and rotation axis orientation components.
The library is available in source code form with versions written in both Fortran and C. It is documented in a technical report available in PostScript format. See Taylor (1997).
[http://www.arl.noaa.gov/ss/models/cmapf.html]
CMIX: A library of C functions designed to create and manipulate sound files. The functions are optimized to do sound processing tasks and can be linked with CMIX disk I/O routines and a command parser called MINC (MINC Is Not C) to build a CMIX instrument, i.e. an executable program. MINC is actually a language that can be used to create compositions which allows for the embedding of loop constructs, variables and conditional tests in the scorefile (i.e. the file containing control data for a CMIX instrument. MINC interprets the programming commands in the scorefile and passes the resulting numerical parameters to the correct CMIX functions. CMIX can output sound from files already created or produce ouput in real time.
The source code for CMIX, written in C, is available and has been compiled and tested on Linux boxes. The documentation is contained within the source distribution and also available online in HTML format. There is a separate Linux version called RTcmix which features improved real time capabilities.
[http://www.music.princeton.edu/winham/cmix.html]
CML: The Chemical Markup Language is a package which extends SGML to the management of chemical information. CML and its associated tools allow for the conversion of current files without semantic loss, structured documents including chemical publications, and the precise location of information within files. While CML requires strict adherence to SGML, it is mostly no more complicated from the user's point of view than HTML. It relies heavily on the use of carefully structured glossaries rather than adding semantics to the language which allows a greater flexibility for adding new terms and even new glossaries without having to revise the language or modify the software.
CML extends the range of structured datatypes found in HTML to include:

numeric and string data in scalar, array, matrix or tabular form (with the glossaries capable of containing run-time code for the validation or transformation of data items);

molecular information including stoichiometry, connection tables, crystallography, symmetry, chirality, atom and bond types, etc. (with sufficient power to represent the common molecular formats chosen in Chemical MIME, a set of chemical extensions for MIME);

scientific units in a separate glossary allowing for the development of code for automatic conversion;

special files containing, e.g. PDB and SWISS-PROT files for a protein with accompanying hypertext; and

provision for chemical reaction and protein sequence information in the testing stages.

The CML package is available as source code. It is written in C and Tcl/Tk and thus requires a compiler and the latter package for installation. Other packages required include sgmls, CoST, BLT, and RasMol. The distribution includes a set of DTDs, a large amount of documentation in TeX and HTML format, glossaries to add semantic content to CML documents, supporting material for HTML 2.0, several examples, and CMLCOST, a browser for CML files created using the CoST package.
[http://www.xml-cml.org/]
CMM: The Customizable Memory Management package supports complex, memory-intensive appliations in C++. It can manage several heaps, with each implementing a different storage discipline. The default heap for collectible objects uses the technique of mostly copying garbage collection, which provides good performance and memory compaction. Temporary and mark and sweep heaps are also available, and users can define their own heap classes.
[http://www.di.unipi.it/~attardi/software.html]
CMN: The Common Music Notation package is a western music notation package written in Common Lisp. It requires either the Adobe Sonata or the Finale Petrucci font. It was developed as a hack to provide a way to translate a CLM note list into a traditional score as well as a way to create editable PostScript files for cut and paste operations.
The CMN source code is available. It is written in Common Lisp and works on NeXT, SGI Indigo, NeXTStep/OpenStep, Mac II, Mac PowerPC, and Linux Intel systems. It can be used on Linux platforms with ACL, CMUCL, CLISP or GCL. The package is documented in a user's manual in HTML format included in the distribution. See also snd and CM.
[http://www-ccrma.stanford.edu/CCRMA/Software/cmn/cmn.html]
CMT: The Continuous Media Toolkit is a toolkit for multimedia applications. It is built on top of the scripting language and GUI toolkit Tcl/Tk and the network tools package Tcl-DP. It is implemented as a collection of objects, each of which handles a specific task, e.g. reading MPEG encoded video from a file or decoding and displaying MPEG encoded video. Other objects exist which support the construction of distributed applications, transmit and receive data using the Real-time Transport Protocol used by the MBONE tools, transmit and receive data across a TCP/IP network using Cyclic-UDP, filter uncompressed video, and display video on the experimental InfoPad.
CMT supports several audio and video encoding formats, including Sparc style audio, MPEG video, MJPEG video, and H.261 video. It also contains support for a number of audio interfaces including the Sparc, Linux and Irix devices as well as DEC's AudioFile. It contains software MPEG, MJPEG and H.261 decoders as well as the capability to perform hardware assisted decompression using the Sun Parallax, SunVideo, DEC J300 or SGI Cosmo board. It also comes with the CMplayer, a sample application that can be used to play audio and video files locally or from a CMT video file server.
The CMT source code is available and compiles under most versions of UNIX and Windows NT. It has been compiled and tested on DEC Alpha, HP 700, Sun SPARC, Linux, SGI and Windows NT platforms. The documentation is included in the source distribution and is also available online in HTML format.
[http://bmrc.berkeley.edu/projects/cmt/]
cmtools: Renamed to ivmkcm.
CMUCL: The CMU version of Common Lisp. This distribution includes an incremental compiler, the Hemlock Emacs-style editor, source code level debugger, and code profiler. It is mostly X3J13 compatible including the new loop macro. The python compiler is more sophisticated than other compilers and produces better code. It performs many optimizations that are absent or less general in other compilers, and is particularly good at number crunching. Other compiler features include good type checking and efficiency at the same time, type declarations are verified in safe code, full source level debugging of compiled code including display of the exact call that got an error, and block compilation, partial evaluation, lightweight functions and proper tail-recursion which allow the low cost use of function call abstraction. Compiler optimizations include interprocedural type inference, global flow analysis, dynamic type inference, global register allocation, stack number allocation, control optimization, integer range analysis, enhanced inline expansion, multiple value optimization, and source-to-source transforms.
CMUCL features which make it good for number crunching include: good inline coding of float and 32-bit integer operations with no number consing, full support for IEEE single and double precision numbers, numbers are passed as function arguments and return values in registers in block compiled code, calls to library functions are optimized to a direct call to the C library routine, and substantially better bignum performance than commercial applications. There are over 50 pages in the user's manual describing the numerical capabilities of CMUCL. The debugger features: Motif-based and command-line interfaces, commands to print the precise original source form responsible for an error, access by name to variables in compiled code, stepping of compiled code, and integration with the Hemlock editor.
The CMUCL distribution is available either as source code or in binary form for several platforms including Linux Intel. It's not a good idea to attempt to compile from source unless your're a mongo wizard. The documentation includes a 150 page user's manual and a 125 page Hemlock user's manual, both of which are available in PostScript.
[ftp://ftp.cc.gatech.edu/pub/linux/devel/lang/lisp/]
[http://www.cons.org/cmucl/]
CMU SNMP: An implementation of SNMP which has been ported to Linux. The current, i.e. 8th, release supports SNMPv1 and SNMPv2, and includes a bilingual agent and several simple command-line management tools. It is based on the CMU SNMP release with USEC support. The MIB modules supported in this release are MIB-2, Identification MIB, Host Resources MIB, and an experimental TUBS Linux MIB. The programs and tools in the distribution include:

snmpd, the SNMP agent which runs as a background daemon;

snmpget, an application which uses the GET request to query for information on a network entity;

snmpgetnext, an application which uses the GET NEXT request to query for information on a network entity;

snmpnetstat, which symbolically displays the values of various network-related information retrieved from a remote system;

snmpset, which communicates with a network entity using SET requests;

snmpstatus, which retrieves several important statistics from a network entity;

snmptrap, which forms and sends a TRAP message to a host;

snmptrapd, which receives and logs TRAP messages sent to the SNMP-TRAP port on the local machine;

snmpwalk, which uses GET NEXT requests to query for a tree of information about a network entity; and

authkey, which creates an authKey for the managing applications.

A source code distribution of the Linux port of CMU-SNMP is available. It can be easily compiled and installed on Linux boxes using the supplied configure script. The applications are documented in a set of man pages.
[http://www.gaertner.de/snmp/]
[http://www.net.cmu.edu/projects/snmp/]

CMU-SNMP-mod

A modified version of the CMU-SNMP package as created by the friendly folks at Carleton University. They state that they've fixed a number of problems in the original code. The date on the code package is 1994, so their fixes may have been also fixed by the CMU people by now (1/99).
[ftp://ftp.sce.carleton.ca/pub/snmp/]

Next: Cn-Cz Up: Linux Software Encyclopedia Previous: Bn-Bz Contents

Manbreaker Crag 2001-03-08