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]

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

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

CScene
[http://www.cscene.org/]

Some popular and useful textbooks which either cover the basic language or its use for performing numerical tasks are , , , , , , , , , , , , , , , , , , , and .
Freely available C compilers, interpreters and other programs that facilitate better C programming and programs include:

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

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]

C++ Programming Information
[http://www.austinlinks.com/CPlusPlus/]

G++ FAQ
[http://www.faqs.org/faqs/g++-FAQ/]

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://www.oonumerics.org/oon/]

Texts covering the application of C++ to scientific computing or object-oriented numerics include , , , and . Also interesting are the series of papers , , , and 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 , , , . , , , , , , , and .
The C++ libraries pertaining to numerical analysis tasks such as linear algebra and the solution of differential equations include:

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

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://okmij.org/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 .
[http://cxxsim.ncl.ac.uk/]
CABLE: An open-source wrapping package, CABLE (CABLE Automates Bindings for Language Extension) is a tool designed to automatically generate bindings to C++ classes for use in interpreted languages. This parses arbitrarily complex C++ code and produces an XML representation thereof. This works in conjunction with and therefore requires GCC-XML.
[http://public.kitware.com/Cable/HTML/Index.html]
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.org/directory/GNU/calc.html]
[http://www.isthe.com/chongo/tech/comp/calc/]
[http://sourceforge.net/projects/calc/]
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.numbertheory.org/calc/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 .
[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): Note: This has been renamed GNU 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://pauillac.inria.fr/~diaz/gnu-prolog/]
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-esd.fnal.gov/esd/catalog/camacdir.htm]
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 .
[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]
[http://www.m3.org/]
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.
[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 . This is part of the USGS WaterLib 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-cs.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.casbah.org/]
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.hio.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.nongnu.org/catalog/]
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.ice.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.

[http://www.rhpcs.mcmaster.ca/~fred/performance.html]
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://cbb.sourceforge.net/]
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.comp.nus.edu.sg/~tayyc/cbrp/]
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/components/]

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/]
[http://www.extreme.indiana.edu/xcat/]
CCC: A web-based inventory, contact management, POS, and job tracking and billing system designed for computer service shops, although it should be applicable to any shop with similar needs. CCC was designed to give small, service-based organizations accountability for their operations. The features include:

tracking customer, contact and technician names and addresses, job information, outgoing bills, jobs, items, vendors and requisitions;

searching previous jobs and bills by description, company name and date; and

an ecommerce add-on that allows visitors to purchase items from an existing item database by creating an account and going through a check-out procedure.

This requires PHP and ADODB.
[http://www.cccsoftware.org/]
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/]
[ccf.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://www.inf.ethz.ch/personal/biere/projects/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.
[http://www.gnu.org/software/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://ccsh.sourceforge.net/]
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.cc65.org/]
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://esg.llnl.gov/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://www.muempf.de/]
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.
[http://www.escape.de/users/colossus/cdda2wav.html]
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://www.joat.ca/software/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://lib.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: Note: The name of this has been changed to MusicBrainz.
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://musicbrainz.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://cdrdao.sourceforge.net/]
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/]
[http://www.math.iastate.edu/docs/cmlib/cmlib.html]
CD-ROM: Information sources for those interested in reading from and writing to CD-ROMs are:

CD-Recordable FAQ
http://www.cdrfaq.org/

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

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 and .
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
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://www.ibiblio.org/pub/Linux/utils/disk-management/]
CEA Miscellaneous Utilities: Note: This seems to have vanished along with the CEA.
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/electro/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.lilikoi.com/sac98.html]
CELEFUNT: A set of Fortran programs for testing complex elementary functions. This is TOMS algorithm 714 and is documented in .
[http://www.acm.org/toms/V19.html]
[http://www.netlib.org/toms/index.html]