Cn-Cz

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z

[home / linux ]

 

CNCL

The ComNets Class Library is a collection of C++ classes featuring generic C++ classes as well as a simulation library with strong points in random number generation, statistics, and event driven simulation. All classes and definitions feature a prepended CN to avoid collision with other class libraries. There are classes for construct various sorts of queues, creating linked lists and a stack, scheduling events, creating 1-, 2-, and 3-D arrays, creating hash tables, character strings, graphics, fuzzy variables and rules, and many more general and specific tasks. An abstract random number generator base class CNRNG includes;

• CNLCG, a linear congruential generator;
• CNMLCG, a multiplicative linear congruential generator;
• CNACG, an additive congruential generator;
• CNFiboG, a lagged Fibonacci generator;
• CNTausG, a Tausworthe generator; and
• CNFileG, a data file random number generator.

An abstract random distribution base class CNRandom includes:

• CNBeta, a beta distribution;
• CNBinomial, a binomial distribution;
• CNDeterm, a deterministic distribution;
• CNDiracTab, a distribution from a table;
• CNDiscUniform, a discrete uniform distribution;
• CNErlang, an Erlang-k distribution;
• CNGeometric, geometric distributed random numbers;
• CNHyperExp, hyperexponential distributed random numbers;
• CNHyperGeom, hypergeometric distributed random numbers;
• CNMDeterm, a random mix of deterministic distributions;
• CNNegExp, a negative exponential distribution;
• CNNormal, a normal distribution base class including lognormal, Rayleight and Rice distributions;
• CNPoisson, a Poisson distribution;
• CNRandomMix, a mix of several CNRandom distributions;
• CNUniform, a uniform distribution; and
• CNWeibull, a Weibull distribution.

An abstract statistics evaluation class CNStatistics includes:

• CNMoments, for evaluation of weighted moments;
• CNMomentsTime, for evaluation of time-weighted moments;
• CNConfidence, for evaluation of moments with confidence intervals;
• CNLRE, a base class for evaluation by LRE F(x);
• CNDLREF, evaluation by discrete LRE F(x);
• CNDLREG, evaluation by discrete LRE G(x); and
• CNBatchMeans, evaluation by batch means.

A source code distribution of CNCL is available. It is written in C++ and can be compiled with GNU g++ and other C++ compilers. A user's and reference manual detailing all of the classes in available in various formats.

[http://www.comnets.rwth-aachen.de/doc/cncl.html]

 

CN

A rule-induction program which takes a set of examples (i.e. vectors of attribute-values) and generates a set of rules for classifying them. It also allows the evaluation of the accuracy of a set of rules in terms of a set of pre-classified examples. The algorithm inductively learns a set of propositional if-then rules from a set of training examples by performing a general-to-specific beam search through rule-space for the best rule, removing training examples covered by that rule, and then repeating the process until no more good rules can be found. The algorithm defines best using the Laplace estimate. The source code for the CN2 system is available and is written in C. It has been compiled on Sun SunOS and SOlaris, SGI IRIX, HP-UX, and Linux Intel platforms. It is documented in a user's manual in LaTeX format included in the distribution. See also Clark and Niblett (1989).

[http://www.cs.utexas.edu/users/pclark/software.html]

 

COAS

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

• a schema definition file which provides a single logical presentation of the data manipulated by a module, with the definition written using a schema definition language;
• a mapper, i.e. a piece of code responsible for converting configuration data from its original format and file into that described by the schema definition (and vice-versa);
• a configurator, i.e. a piece of code that controls the user interface for manipulating configuration data, using a generic interface API to present menus, dialogs, and screens for screen interaction;
• core engine services, i.e. an engine written in C++ which provides data modeling handling and several additional services (e.g. logging, version control, data consistency checks, etc.).

Source code distributions of development versions of COAS (1/98) are available. They can be compiled and used on Linux platforms via the supplied configuration scripts. Full use of the package also requires ncurses, Python, readline, and Qt.

[http://www.caldera.com/coas/]

 

Cobcy

A program which compiles ANSI COBOL sources into readable ANSI C sources. It doesn't support some features like arrays, string operations, and record-record MOVEs. Relative and indexed files are in dBASE III format so a DBF library in included. This was developed on a Linux platform. [ftp://tsx-11.mit.edu/pub/linux/sources/usr.bin/]

 

COBOL

A language making a big comeback due to the Year 2000 software problem. Freely available compilers are Cobcy and Deskware COBOL. The given URL is to the COBOL Center. [http://www.infogoal.com/cbd/cbdhome.htm]

 

Cocktail

A set of program generators or compiler construction tools for nearly all phases of a compiler. The performance is claimed to be quite a bit faster than for the comparable lex and yacc tools. Cocktail consists of several parts. Rex, the regular expression tool, is a scanner generator whose specifications are based on regular expressions and arbitrary semantic actions written in one of the target languages C or Modula-2. Lalr is a LALR(1) parser generator that accepts grammars written in extended BNF notation which can be augmented by semantic actions expressed by statements in the target language. The generated parsers included automatic error recovery, error messages, and error repair. Ell is an LL(1) parser generator which accepts the same specification language as Lalr except that the grammars must be LL(1). Ast, a generator for abstract trees, generates abstract data types (program modules) to handle trees. The trees may be attributed and nodes may be associated with arbitrarily many attributes of arbitrary type. Specifications are based on extended context-free grammars, and a common notation is used for concrete and abstract syntax as well as for attributed trees and graphs. Other features include an extension mechanism providing single inheritance, trees stored a linked records, generation of efficient program modules in C or Modula-2, provision of many tree operations (procedures), node constructors which combine aggregate notation and storage management, ASCII and binary graph readers and writers, top down and bottom up traversal, and an interactive graph browser. Ag, an attribute evaluator generator, processes ordered attribute grammars (OAGs) and higher order attribute grammars (HAGs). It operates on abstract syntax and is based on tree modules generated by Ast. Addition features include that in Ag: the tree structure is fully known, attributes can have any target language type, tree-valued attributes are allowed, an extension mechanism is offered, attribute computations are written in a functional style, AGs can consist of several modules, AGs are checked for completeness of the attribute computations as well as for unused attributes, the evaluators are directly coded using recursive procedures, and more. Puma is a transformation tool based on pattern matching.

The Cocktail toolbox is implemented in Modula-2. It was developed and can be used with the freely available MOCKA compiler. A extensive user's guide is available in PostScript format. The Cocktail tools can also understand lex and yacc syntax with the help of a couple of preprocessors supplied in the distribution.

[http://www.first.gmd.de/toolkit/cocktail/]

 

CoCoA

Computations in Commutative Algebra is a computer algebra system designed for maximum ease of use and flexibility for mathematicians who aren't computer gurus. CoCoA can perform simple and sophisticated operations on multivariate polynomial rings and on various data connected with them such as ideals, modules, matrices and rational functions. In additional to performing such basic operations as sums, products, powers and derivatives of polynomials, rational functions and ideals, several more advanced operations are available including:

• Groebner bases, syzygies, minimal free resolutions, intersection and division, and inclusion and equality tests for ideals and modules;
• elimination of indeterminates;
• homogenization of ideals;
• Poincare series and Hilbert functions; and
• factorization of univariate polynomials over the integers.

The CoCoA system consists of a kernel written in C and a library of programs written in a Pascal-like programming language called CoCoAL that lets users customize and extend the system. It is portable to different machines via an interface to a platform-independent Low Level Protocol (LLP) layer. The platform independent part consists of two modules. ENGINE is the main motor, an interpreter for CoCoAL which allows it to exchange LLP inputs and outputs with the interface. Computational requests are forwarded from ENGINE to MATH, which contains all of the mathematical algorithms to manipulate coefficients, polynomials, ideals and modules. It accepts requests, converts data from LLP to an internal format, and then performs the mathematical task.

Binary distributions of CoCoA are available for several platforms including Linux Intel. Documentation includes a user's manual and a tutorial as well as several technical reports concerning the development of the system.

[http://cocoa.dima.unige.it/]

 

Coco/R

A tool that combines the functionality of lex and yacc to form a compiler generator that generates recursive descent parsers, their associated scanners, and a driver program from attributed grammars (in EBNF syntax) which conform to LL(1) parsing restrictions. To get a running compiler, the user has to add modules for symbol table handling, optimization, and code generation. There are versions of Coco/R available for Oberon, Modula-2, Pascal, C/C++, and Java. [http://cs.ru.ac.za/homes/cspt/cocor.htm]

 

Coda

An advanced networked file system descended from the Andrew File System (AFS). It contains several features needed by networked filesystems and usually not available elsewhere. These include: high performance via client-side persistent caching; server replication; a security model for authentication, encryption and access control; disconnected operation for laptops; continued operation during partial network failures in the server network; network bandwidth change adaptation; good scalability; and well-defined semantics of sharing even during network failures. A pre-alpha version (5/97) is available for Linux platforms. It is available in the form of either an RPM package or a tarred and compressed file. There is a large collection of documents available in PostScript format which document the system and its various parts.

[http://www.coda.cs.cmu.edu/]

 

CodeLib

A collection of codes developed by Prof. P. Deuflhard and his colleagues at Konrad-Zuse-Zentrum fuer Informationstechnik Berlin (ZIB). These mainly deal with solutions of single or systems of differential and/or algebraic equations. The programs in CodeLib include: ALCON1, ALCON2, ALCON-S, BVPLSQ, BVPSOG, BVPSOL, DIFEX1, DIFEX2, DIFEXM, EULEX, EULSIM, GBIT, GIANT, KEPLEX, LARKIN, LIMEX, LIMEXS, METAN, MEXX, MULCON, NLEQ1, NLEQ2, NLSCON, PERHOM, PERIOD, and SYMCON. [ftp://elib.zib.de/pub/elib/codelib/]

 

CODE

The Computationally-Oriented Display Environment is a visual parallel programming system which allows users to compose sequential programs into a parallel program. The parallel program is a directed graph where data flows on arcs connecting nodes that represent sequential programs. The sequential programs can be written in any language and CODE will produce parallel programs for a variety of architectures. It is primarily designed to support coarse-grained parallelism with the chunks usually written in C although they can be written in any language that can be linked into C. CODE can produce programs for three types of architectures: (1) a purely sequential program that simulates parallelism; (2) a shared-memory multiprocessor machine such as the Cray J90 or Sun SparcCenter that uses POSIX threads; and (3) a distributed memory cluster that uses either PVM or MPI. CODE should run on any UNIX system. [http://www.cs.utexas.edu/users/code/]

 

Code Crusader

A C/C++ code development environment written using the JX package. The features include: the graphical display of a C++ inheritance hierarchy with searching for classes by name, searching for classes that implement a particular function, lists of functions implemented by a particular class, instant access to source and header files, and output in PostScript format; integrated support for make which parses error messages from gcc and opens the file to the line where the error occurred as well as integrated support for executing or debugging the result; a text searching window; file backup; memory of preferred window geometries for each file type; a multiple document interface which prevents mistakes caused by editing the same file in different windows; project support which remembers which files were open in where in each you were working as well as the commands used; configuration performed via dialog windows rather than config files; on-line help; and more. A source code distribution is available as are binaries for several types of platforms including Linux Intel. Compilation requires the JX library.

[http://www.cco.caltech.edu/ jafl/jcc/]

 

CODE++

Classes for Ordinary Differential Equations is a collection of C++ class libraries for ordinary differential equations and related problems. It was originally developed to unify a family of adaptive extrapolation codes and some multiple shooting method programs based on these integrators, and it has also been used for the fast prototyping of new numerical algorithms, with one example being the COST package. The classes in CODE++ are divided into several smaller libraries. The matlib library contains basic linear algebra classes and utilities collected into utility, basic linear algebra, and basic container classes. The odelib library contains classes for the description of ODEs and their solution via adaptive integration methods. The subclasses here contain ODE descriptors, adaptive order and stepsize control integration methods based on local error estimation and some error model, extrapolation methods to generate solutions of higher order, and and methods for accessing information about the solution of an ODE during the integration process. The nonlin library deals with nonlinear problems and solvers, currently differentiable unconstrained nonlinear problems and Newton-like methods for their solution. The sparse library contains sparse matrix classes and interfaces to sparse solvers, with the latter being Harwell's sparse matrix solver. The shoot library contains multiple shooting method algorithms. The latool library contains an interface to the linear algebra package LAPACK. The special library contains special functions like Bessel functions.

A source code distribution of CODE++ is available. It is written in C++ and has been compiled on several different compilers. It has been compiled with gcc 2.5.8 but as of this writing (6/97) has not been adapted to the new template scheme of 2.6.*. The classes are documented in both HTML and PostScript formats, and a user's guide is also included in HTML format.

[ftp://elib.ZIB-Berlin.de/pub/code++/]

 

ColEm

A portable emulator for the ColecoVision video game system. This is written in C with source code and binaries available for several platforms. The UNIX version is available as source code. [http://www.komkon.org/fms/ColEm/]

 

COLMOD

An extension of the COLNEW package for the solution of singularly perturbed boundary value problems (BVPs) using an automatic continuation strategy. This differs from COLNEW in that it uses a different mesh selection algorithm more amenable for use with the boundary layers found in such problems. See Cash et al. (1995). [http://www.ma.ic.ac.uk/~jcash/BVP_software/readme.html]

 

COLNEW

A package for the solution of boundary value problems (BVPs) for ordinary differential equations (ODEs). COLNEW is a modified version of the COLSYS package wherein the B-splines are replaced with a collocation method. A Runge-Kutta-monomial solutin method is used. The program is written in Fortran and is documented in the source code. This program is extended in COLMOD. See Ascher et al. (1981) and Bader and Ascher (1987). [http://www.ma.ic.ac.uk/~jcash/BVP_software/readme.html]

 

COMEDI

The COntrol and MEasurement Device Interface is a collection of hardware drivers, a common kernel interface, and a support library for data acquisition hardware. It is implemented as a kernel module that is accessed via character devices, and the library is used to facilitate communication with the driver. The driver currently (7/98) supports several hardware devices including:

• Data Translation DT2811, DT2814 and DT2817;
• Data Translation DT2821 series;
• National Instruments AT-MIO E series;
• Generic 8255 chip support;
• PCL-711 PC LabCard; and
• standard parallel printer port.

A source code distribution is available. [http://www.llp.fu-berlin.de/pool/software/comedi/]

 

Common Lisp

A dialect of the Lisp language whose origins can be traced to a DARPA sponsored meeting held in 1981 when a group of Lisp users met to attempt to unify what were becoming too many divergent versions of Lisp. Common Lisp was designed as a description of a family of languages with the semantics deliberately underspecified in places to prevent an overly tight specification from hindering research and use. A technical working group called X3J13 was formed in 1986 to produce a draft for a Common Lisp standard. Their goals differed from those of the earlier group for various reasons and included stricter standardization for portability, an object-oriented programming system, a condition system, iteration facilities, and a way to handle large character sets.

The goals for which Common Lisp was designed by the 1986 group include: commonality, i.e. to serve as a common dialect to which each implementation can make necessary extensions; portability in that it is easy to write programs that depend as little as possible on machine-specific characteristics; consistency, i.e. an explicit requirement for the interpreter and the compiler to impose identical semantics on correct programs as much as is possible; expressiveness, i.e. the use of the most useful and understandable constructs from several previous Lisp implementations; compatibility, i.e. striving to be compatible with various previous implementations unless there is a good reason not to; efficiency, i.e. a number of features designed to facilitate the production of high quality compiled code in implementations which include and optimizing compiler; power, i.e. the provision of quality system building tools; and stability, i.e. the specification will change slowly.

Packages which implement Lisp interpreters and/or compilers or Commmon Lisp extensions include:

• AKCL,
• Allegro Common Lisp,
• CLiCC,
• CLISP,
• CMUCL,
• ECL,
• EusLisp,
• GCL,
• KCL, and
• Screamer.

See the CMU Common Lisp Repository . See Allen (1978), Cameron and Dixon (1992), Gabriel (1985), Graham (1994), Graham (1996), Harrison (1990), Hasemer and Domingue (1989), Hennessey (1989), Keene (1989), Koschmann (1990), Lawless and Miller (1991), Miller and Benson (1990), Norvig (1992), Paepcke (1993), Queinnec (1996), Sangal (1991), Shapiro (1992), Steele (1990), Touretzky (1990), and Winston and Horn (1989).  

Communication System Toolbox

A Matlab toolbox containing a collection of programs (m-files) for performing various tasks on the digital coding of waveforms and on digital data transmission systems. This was developed for an interactive laboratory course at a university. The nearly 100 m-files in this package are used for the performance of seven laboratory simulations. The topics covered are probability theory, random processes, quantization, binary signalling formats, detection, digital modulation, and digital communication. The Toolbox can be used with Matlab or with the freely available Octave which can run most Matlab m-files. It is documented in a 106 page lab manual in PostScript format created for the course.

[http://www.mathworks.com/miscv4.html]

 

compiler construction tools

Such tools can be divided into several categories including:

 
• compiler construction kits
  • Cocktail, a set of generators for most phases of a compiler;
  • Eli, programs for almost all of the tasks required to create a language;
  • Gentle, an integrated system for compiler construction with all the necessary tools; and
  • PCCTS, a tool for the construction of language recognizers and translators.
  a  
• lexer and parser generators
  • ALE, a logic programming and grammar parsing and generation system;
  • BtYacc, a modified yacc supporting automatic backtracking and semantic disambiguation for parsing ambiguous grammars;
  • Bison, the GNU version of yacc;
  • byacc, the Berkeley version of the AT&T yacc;
  • Coco/R, a tool combining the functionality of lex and yacc;
  • Depot4, a system for implementing language processors that used an extension of EBNF called Ml4;
  • EAG, a compiler that uses the EAG formalism;
  • Elex, a multi-language scanner generator that generates a scanner from a specification oriented around regular expressions;
  • Flex, the GNU version of lex;
  • LLgen, a tool for generating an efficient recursive descent parser from an ELL(1) grammar;
  • NewYacc, an extensino to yacc;
  • PRECCX, an infinite-lookahead compiler compiler for context dependent grammars;
  • RDP, a parser generator that compiles attributed LL(1) grammars decorated with C semantic actions into recursive descent compilers;
  • SYNTAX, a system combining the capabilities of lex and yacc with extract features including better error processing;
  • Zlex, a lex-compatible scanner generator with additional features; and
  • Zyacc, a general purpose parser generator that converts descriptions in LALR(1) into C programs to parse that grammar.
   
• attribute grammar systems
  • Elegant, a programming language based on attribute grammars;
  • FNC-2, an AG system based on strongly non-circular AGs that performs extensive space optimizations;
  • Ox, an attribute grammar compiling system; and
  • RIE, a package based on one-pass AGs called ECLR-attributed grammars.
   
• transformation tools
  • RIGAL, a compiler construction language whose data structures are atoms, lists, and labeled trees and whose control structures are based on advanced pattern matching;
  • TXL, a programming language and rapid prototyping system designed to support transformational programming;

 

Computational Fluid Dynamics

An extensive list of freely and commercially available computer programs pertaining to the broad sweep of computational fluid dynamics. [http://www.math.psu.edu/dna/CFD_codes.html]
[http://www.fges.demon.co.uk/cfd/CFD_codes.html ]

 

computer algebra

Several packages are available for performing computer algebra computations on Linux platforms. These include the Computer Algebra Kit, FELIX, FORM, GAP, Calc, JACAL, KANT, Macaulay2, MAS, Mathomatic, MAXIMA, Mockmma, MuPAD, NTL, PARI-GP, Risa, SACLIB, SAML, SIMATH, Singular, and Symmetrica.

 

Computer Algebra Kit

A collection of programs or objects for performing computer algebra tasks. The kit provides objects for multi-precision integer arithmetic, computing with polynomials, computing with matrices of integers, and more. There versions of this for NextStep, Stepstone and GNU Objective C. Demo version for the latter are available for Sun and Linux platforms. [http://www.can.nl/~stes/]

 

Condor

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

• checkpointing and migration in which a program running on a computer can, when the situation demands, be either stopped, saved and restarted on another machine or on the same machine, with regular checkpointing also available for protecting accumulated computations;
• preservation of the local execution environment via RPCs so users don't have to worry about making data files available on remote workstations or obtaining accounts on them;
• no special programming is needed to use Condor in that everything other than the Condor-specific calls are transparent to the user;
• complete and automatic control of use priority by the owners of each computer in a Condor cluster; and
• a ClassAd mechanism which provides a flexible, semantic-free and expressive framework for matchmaking between resource requests and resource offers.

Condor can be obtained in source code form or in binary format for several platforms, e.g. Linux Intel, SGI Irix, HP HPUX, Sun Solaris, and DEC ALpha. The documentation is included in each distribution and is also available separately. A Condor View Library, written in Tcl/Tk, is available as an ancillary package. Although not included in current (3/97) releases, a Condor Application Resource Management Interface (CARMI) will be integrated into future releases. It is a framework for interfacing resource management systems with parallel processing systems, with the current version interfacing with PVM. There is a special set of pages for the Condor Linux port . [http://www.cs.wisc.edu/condor/]

 

confcntlr

An MBone conference controlling tool intended to allow easier access to, control of, and coordination of a videoconference over the Web. It is run on all machines participating in the videoconference and is used to control the audio and video portions. It was developed to be used with vic and vat. The confcntlr GUI allows a user to initiate actions and set the controls for both the video and audio. A source code distribution is available. It is written in C and Tcl/Tk and can be compiled on most UNIX platforms. [http://www-itg.lbl.gov/mbone/confcntlr/]

 

Confman

A tool for initiating and administering online conferences using the Mbone tools. Confman does not itself handle multimedia data but rather helps the user to plan, set up, and control a conference. It allows you to choose your partners, the starting time, and the tools you wish to use. It can be used in both unicast and multicast mode and also supports closed conferences. Binary distributions are available for several platforms including Linux Intel. Documentation is mostly in German with some in English. [http://www.rvs.uni-hannover.de/products/confman/index_en.html]

 

CONFPACK

A package of Fortran subroutines to perform conformal mapping using Symm's integral equation. In addition to the confpack file there are also files called pargen and confdrivers which are, respectively, a preprocessor and example driver programs for CONFPACK. The routines in the CONFPACK distribution include:

• JAPHYC, which solves Symm's integral equation to estimate to Jacobi coefficients for the density associated with the map;
• GQPHYC, which sets up the global composite Gaussian quadrature rule for computing the map;
• DMPHYC, which computes the vector of approximate image points in the canonical domain given a vector of arbitrary points in the physical domain;
• CNDPLOT, which examines the condition of the mapping problem and outputs data for plotting graphs of the boundary correspondence function and its derivative;
• JACANP, which estimates the Jacobi coefficients for the density associated with the map;
• GQCANP, which sets up the global composite Gaussian quadrature rule for computing the map;
• DMCANP, which computes the vector of approximate image points in the physical domain given a vector of arbitrary points in the canonical domain;
• BMPHYC, which computes the corresponding approximate image point on the unit disc given a point on the boundary of the physical domain;
• BMCANP, which computes the corresponding approximate image point on the boundary of the physical domain given a point on the unit circle; and
• LEVCUR, which generates level curve plotting data.

A source code distribution of CONPACK is available. It is written in Fortran 77 and there seems to be no documentation available other than scattered comment statements contained within the source code files. There is supposed to be a user's guide to the package but the given FTP address no longer accepts anonymous FTP.

[http://www.netlib.org/conformal/index.html]

 

CONICAL

A C++ class library for building simulations commmon in computational neuroscience. CONICAL currently focuses on compartmental modeling in which a model neuron is built out of compartments, i.e. open-ended cylinders which can approximate almost any geometry. All compartments have passive electrical properties as well as more interesting properties which require the use of active ion channels whose conductance varies as a function of the time or membrane voltage. Connections between neurons can be implemented in several ways. For example, a passive current is used for a gap junction. Both alpha-function and Markov-model synapse models are available. The classes in CONICAL include:

• AlphaSyn, an alpha-function synapse;
• Channel, a variable conductance current;
• ChanAB, an alpha/beta Hodgkin-Huxley channel;
• ChanHH, a Hodgkin-Huxley ion channel;
• ChanStd, a standard Hodgkin-Huxley ion channel;
• Compartment, an isopotential volume;
• Current, a current source to a VSink;
• Cylinder, an isopotential, cylindrical compartment;
• Delay, a link with a time delay;
• Injector, an ideal current source;
• Link, a VSource to VSink connection;
• Markov, a Markov kinetic model;
• MarkovSyn, a Markov synapse;
• Spiker, an integrate-and-fire compartment;
• Stepmaster, which unites a set of Steppers;
• Steppers, which provides a step(dt) method;
• StepStream, a columnar output generator;
• Synapse, a neurotransmitter gated channel;
• VSink, a voltage sink; and
• VSource, a voltage source.

A source code distribution of CONICAL is available. It is written in C++ and known to compile on Linux platforms using gcc 2.7.0 or later. A user's guide is included in the basic distribution.

[http://www-acs.ucsd.edu/~jstrout/conical]

 

CONTENT

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

• continuation of equilibria;
• detection of branching, limit and Hopf points for equilibria;
• continuation of codimension 1 bifurcations (fold and Hopf);
• detection of codimension 2 equilibrium bifurcations (cusp, Bogdanov-Takens, generalized Hopf, zero-Hopf, and double Hopf);
• conditional continuation of equilibrium and codimension 1 bifurcations;
• branch switching between equilibrium bifurcations; and
• simulation using Euler and Runge-Kutta methods.

It can also handle iteration maps and both continuation of steady states and detection of branching and limit points of PDEs on the unit interval.

CONTENT is available in binary format for SGI IRIX, Linux Intel, DEC Alpha, Sun SunOS, IBM AIX, and MS-DOS/Windows platforms. The documention is contained within a built-in help utility in the software.

[http://www.can.nl/Systems_and_Packages/Per_Purpose/Special/DiffEqns/Content/GCbody.html]
[ftp://ftp.cwi.nl/pub/CONTENT/ ]

 

CONTIN

A package which implements a CONTINuation algorithm with an adaptive choice of a local coordinate system. It computes a sequence of solution points along a 1-D manifold of a system of nonlinear equations. It functions somewhat like an IVP ODE solver in that the user must specify an approximate initial solution, but it doesn't attempt to solve the problem by turning it into a system of ODEs. Rather, it selects a suitable variable as the current parameter at each time step and then determines the other variables as function of it. This lets the algorithm handle solutions curves which may bend and switch back in any direction. CONTIN solves the algebraic equations explicitly at each step and each solution has to pass an acceptance test in an iterative solution process with tolerances supplied by the user. It is designed for systems with one degree of freedom, but can be used with more complicated systems by introducing suitable constraints to the nonlinear equation system which will serve to reduce the number of degrees of freedom. Options include the ability to search for solutions for which a given component has a specified value, and searching for a limit or turning point with respect to a given component.

A source code distribution of CONTIN is available. It is written in Fortran 77. Also available are several sample problems in the form of Fortran programs. It is documented in comments within the programs as well as in Rheinboldt and Burkardt (1983), Rheinboldt and Burkardt (1983), and Rheinboldt (1985). See the MANPAK entry for an updated and expanded version of this software. This is also known as PITCON.

[http://www.netlib.org/contin/index.html]

 

Converse

A portable parallel programming framework which can be used for developing portable parallel programs with support for messages, threads, shared memory, message handlers, and flexible schedulers. It can be used for quickly and easily building efficient runtime systems for parallel languages and also supports multilingual operability, i.e. modules written in different parallel languages can be linked together in a single application and carry out concurrent computations. This is achieved by a component-based (rather than layered) architecture in which only the components used incur a computational cost. The components of Converse include:

• a machine interface which includes messages, handlers, shared variables, locks, timers, etc.;
• a simple, portable, and flexible thread abstraction;
• a general purpose scheduler with customizable queueing strategy used for scheduling threads, message handlers, and any other user-defined entities;
• a load balancer which handles the assignment of new objects of small tasks to processors;
• a message manager to store and retrieve entities (usually messages) based on one or more indices or tags which can be used for implementing languages like PMV, Nxlib, or threaded versions of them; and
• parameter marshalling, useful for directly programming using Converse which supports the marshalling of C function parameters for a well-defined class of types.

The languages currently (3/97) implemented include Charm and Charm++ (included in the distribution), a simple tag-based message passing library (SM) and its threaded version (tSM), PVM, MPI, a discrete event simulation language called Parallel Import, and an experimental language called Agents.

Converse runs on networks of UNIX workstations (currently Sun SunOS and Solaris, IBM RS/6000, and HP), the IBM SP1, the CM-5, the Paragon, the NCube, and the Cray T3D. Several Converse components are available only in binary form for the listed platforms, although support for more platforms is promised. I've already sent a request for Linux. The documentation is contained within several user's guides and reports, all of which are available in PostScript format. See Kale et al. (1996).

[http://charm.cs.uiuc.edu/]

 

conversion programs

Programs or program suites that convert one type of image, text, or data file into another type. Image conversion programs include:

• fbm2fli, from 8 bit image to FLI/FLC animation;
• hpcdtoppm, from Photo-CD to PBM;
• ppm2fli, from PPM, PGM, PBM to FLI animations and vice-versa; and
• XIcon, from XBM, OS/2, Windows, and Mac icons to XPM.

 

CONVERT

A Starlink Project package containing utilities for converting data files between Starlinks extensible N-dimensional Data Format (NDF) and a number of other common data formats. The currently (6/97) conversion programs included in the package and their conversion tasks are: ASCII2NDF and NDF2ASCII, between a text file and an NDF; DST2NDF and NDF2DST, between a Figaro DST file and an NDF; GASP2NDF and NDF2GASP, between an image in GASP format and an NDF; GIF2NDF and NDF2GIF, between an image in GIF format and an NDF; IRAF2NDF and NDF2IRAF, between an IRAF image and an NDF; IRCAM2NDF, from an IRCAM data file to a series of NDFs; NDF2FITS, from an NDF to a FITS file; NDF2PGM, from an NDF to a PGM file; NDF2TIFF and TIFF2NDF, between an NDF and a TIFF file; and NDF2UNF and UNF2NDF, between an NDF and a sequential unformatted file. There are also FITS readers in the KAPPA program which convert FITS files to NDFs.

A binary version of CONVERT is available for Linux Intel, DEC OSF, and Sun Solaris platforms. The package is documented in a 44 page user's guide in PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

Cook

A make-like program for constructing files and maintaining referential integrity between files. It is given a set of files to create and recipes for how to create and maintain them. Cook can handle Fortran and C sources. The Cook source code is available. It is written in C and can be compiled on generic UNIX systems. The package is documented in a user's guide available in PostScript format.

[ftp://ftp.agso.gov.au/pub/Aegis/]
[http://sunsite.unc.edu/pub/Linux/devel/make/ ]

 

cooledit

An X Window text editor which supports multiple windows. The interface has a 3-D look and feels vaguely like Motif. The features include: an extensible file size limit of 16 Mb, binary file editing, block copy, move, delete, cut, paste, undo, pull-down menus, file insertion, regular expression search and replace, scanf-printf search and replace, shift-arrow text highlighting, mouse text highlighting, macro recording, insert-overwrite toggle, and an option to pipe text blocks through shell commands like indent. It also remembers the state of its desktop when exiting and allows the cycling through many edit windows with a keystroke. A source code distribution of cooledit is available. It is written in C and requires only the X11 standard libraries for compilation and use. It is documented in a man page.

[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]

 

Cool

The Classroom Object-Oriented Language is a small language designed for use in an undergraduate compiler course. Cool has many of the features of modern programming languages including objects, automatic memory management, and strong static typing. It was designed to be modular in that there are no dependencies between the assignments, to be highly portable on UNIX platforms, and to be easy to modify and extend (to minimize the work needed to develop new assignments). Cool generates code for the SPIM MIPS simulator. Distributions of Cool are available for several platforms including DEC Alpha and MIPS, Linux Intel, HP-UX, Sun SunOS, and IBM AIX. The distributions contain an executable of the coolc compiler, assignments, and all documentation. The source code for the compiler is not included.

[http://http.cs.berkeley.edu/~aiken/cool/index.html]

 

CooL-SPE

The Combined object-oriented Language Software Production Environment is a programming environment designed to support the professional development of large-scale object-oriented application systems. Cool-SPE supports the development of application systems with graphical user interfaces (GUIs) based on Motif with the GUIs being constructed using either a user interface language (UIL) or interactively with a dialog editor. A dialog object class library called DIO is available to facilitate the integration of the application with the X/Motif runtime system. Applications are built using a modern, object-oriented 4th-generation programming language called CooL which features single inheritance, dynamic binding and polymorphism. It also offers generic object types and abstract object types as well as supporting modules in the tradition of Modula to facilitate building large systems.

The CooL language is extended by the CooL library system CoLibri which offers a BCD type and a number of functions for the CooL simple types. It provides foundation object types such as basic file I/O as well as basic container object types such as sets, lists, maps, etc. A source-level debugger called MaX is also provided offers the functionality of the UNIX sdb debugger. It can additionally process (un)conditional breakpoints, tracepoints, resolve inheritance, and dereference pointers. Other features include command history, named command sequences, and an online help facility. A Test Object Interface (TOI) allows the user to carry out quality assurance by providing a runtime frame into which object types can be mounted and interactively executed. Both intermediate results and arguments can be recorded during execution and used as compare targets when running a test battery automatically. An SQL Object Interface (SOI) is provided to allow object-oriented applications to be integrated with a relational database system. This interface offers access to SQL tables via a generated object type interface, and also generates the C program including embedded SQL code for accessing the SQL database.

A source code distribution of CooL-SPE is available. It is written in the Gentle compiler construction language which must be installed to compile and use CooL-SPE. It has been compiled on Linux Intel, Sun Solaris, and SINIX platforms. It is documented in a series of reference manuals available in PostScript format as well as in a set of man pages.

[http://www.first.gmd.de/gentle/examples.html]
[ftp://ftp.fu-berlin.de/pub/unix/languages/cool/ ]

 

COOOL

A package of tools for writing optimization code and solving optimization problems, which special interest by the developers in inverse problems. It consists of a library of C++ classes which facilitate in developing optimization codes. It also has a suite of general purpose routines for solving linear and nonlinear inverse problems. [http://www.cwp.mines.edu/cwpcodes/coool]

 

Coral

A project to develop a robust and efficient deductive database system and to investigate its use in various application domains. Coral is a deductive system which supports a rich declarative language and an interface to C++ which allows for a combination of declarative and imperative programming. The declarative query language supports general Horn clauses augmented with complex terms, set-grouping, aggregation, negation, relations with tuples which contain universally quantified variables, and uses a Prolog-like syntax. The features of Coral include: support for many evaluation techniques including bottom-up fixpoint evaluation and top-down backtracking; a module mechanism wherein modules are separately compiled with different evaluation mechanisms possible in each module; support for a broad class of programs with negation and set-generation; support for several data types including numeric and string constants, functor-terms, lists, sets, and multisets; support for data resident on a disk via an interface with the Exodus storage manager; a Tcl/Tk package which allows users to examine derivation trees using a GUI; an interface to C++ is provided which allows relations defined using the declarative language to be manipulated via C++; and more. A GUI shell for the entire Coral system written in Tcl/Tk is also available, with which the on-line help facility can be accessed as well.

The source code for the Coral system is available as are binaries for Sun SunOS and Solaris, HP-UX, and Intel Linux platforms. Compilation requires a C++ compiler (g++ will do), the Tcl/Tk packages, and the GNU Readline library. In addition to the on-line help facility, Coral is documented in several technical reports available in PostScript format.

[http://www.cs.wisc.edu/coral/]

 

CORBA

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

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

CORBA related software tools and packages include ACE, CorbaScript, DOME, Fnorb, ILU, Jorba, OmniBroker, omniORB, PTool, ROBIN, and WebbinCMIP. See Ben-Natan (1995), Mowbray (1997), Otte (1996), and Vinoski (1997).

[http://www.omg.org/]

 

CorbaScript

An interpreted object-oriented language whose main functionality is operation invocation onto objects. It is ORB-independent and based on standard CORBA components. CorbaScript manages variables and control flow statements as well as interpreting scripts and construct requests with DII according to information in the scripts. The Interface Repository is used to control parameter types and infers types like CORBA structures, arrays, and sequences. The instruction types available for the scripts include print, assignment, control flow, exception management, and operation call instructions. The scripts handle values and variables with the values capable of being basic objects like integers, floats, or strings; sets of values; the result of an operation invocation on an object; any CORBA typed value composed of an IDL type and a set of values; any expression of values with standard operators; or a CORBA object reference. A source code version of CorbaScript is available. It is written in C++ and has been compiled on Linux and Solaris platforms using g++ 2.7.2. It is compatible with and uses OmniBroker 2.0. Documentation is available in the form of several technical reports.

[http://corbaweb.lifl.fr/Download/index.html]

 

COSMICS

A package of Fortran programs useful for computing transfer functions and microwave background anisotropy for cosmological models as well as for generating Gaussian random initial conditions for nonlinear structure formation simulations of such models. This package is intended to provide a standard set of numerical tools which can be used by the cosmology simulation community. It generates accurate results of linear evolution which are sufficient for first-order comparison with observations of the microwave background. It can also provide matter distribution input for nonlinear evolution codes. The package consists of several individual programs. LINGER integrates the coupled, linearized, Einstein, Boltzmann and fluid equations governing the evolution of scalar metric perturbations and photons (of both polarizations), neutrinos (massless and massive), baryons, and cold dark matter in a flat Robertson-Walker universe, i.e. it computes the linear evolution of fluctuations generated in the early universe through the radiation dominated era and recombination down to a small redshift input by the user. There are separate versions of LINGER a synchronous gauge and for a longitudinal or conformal Newtonian gauge. The DELTAT program integrates the photon transfer functions computed by LINGER to produce photon anisotrophy power spectra. GRAFIC normalizes the power spectrum of matter density fluctuations and generates initial conditions needed for nonlinear cosmic structure formation simulations.

The source code for the COSMICS package is available. It is written in Fortran 77 and can be compiled using the g77 compiler. The programs are documented in a user's manual included in the distribution in LaTeX format. A parallel version of LINGER is available which can be used with MPI, PVM, or MPL.

[http://arcturus.mit.edu/cosmics/]

 

CoST

The Copenhagen SGML Tool is a general purpose SGML post-processing tool. CoST is a structure-controlled SGML application, i.e. it operates on the element structure information set (ESIS) representation of SGML documents. It is implemented as a Tcl extension which works with the nsgmls parser. It provides a flexible set of low-level primitives upon which sophisticated applications can be built, including: a powerful query language for navigating the document tree and extracting ESIS information; an event-driven programming interface; and a specification mechanism which binds properties to nodes based on queries. A module called Simple is available which provides a simplified, high-level interface for developing translation specifications. It automatically handles a large number of simple types of translations to ease the use of a powerful but somewhat complex system. The RATFINK library of Tcl routines for generating RTF output includes a CoST script form converting SGML to RTF.

The source code for CoST is freely available. Installation and use requires sgmls, Tcl 7.4, [incr Tcl] 2.0, and optionally Tk and TclX. The package is documented in a user's manual available in HTML and PostScript formats.

[http://www.art.com/cost/]

 

COST

The Coupled Oscillator Simulation Tool provides the numerical tools and a graphical user interface (GUI) for the simulation of coupled systems of identical oscillators. It is mainly intended for those working on coupled oscillator systems and their symmetry properties in applied mathematics and engineering. Three elements define a coupled system: cells, which are given by an ODE typically of low dimension; coupling matrices, which give the pattern of the coupling as defined by a Boolean matrix; and coupling maps, which describe the function that couples a pair of cells if they are connected. Thus a coupled system is defined by a cell (type), the number of cells, and a list of couplings. Each of these key elements is represented by an abstract class describing its functionality. A source code distribution of COST is available. It is written in C++ and requires both CODE++ and InterViews for compilation and use. See the CODE++ entry for further information about compilation on Linux platforms. The classes are described in both HTML and PostScript format, with a terse user's guide also available in HTML format.

[ftp://elib.zib-berlin.de/pub/code++/]

 

Counterpoint

A mechanism for communication and synchronization among the different elements of a parallel program. Counterpoint is designed to be used on tightly-coupled distributed-memory systems, suitable for writing applications directly or for programming higher-level constructs for use by application programmers, suitable for irregular and unpredictable computations as well as regular ones, and capable fo producing architecture-independent programs. The memory system consists of nodes containing memory and one or more processors connected by a communication network. Counterpoint defines a large address space of global variables distinct from the local address spaces of the processes, with the global variables accessed via Read and Write operations. There is one global variable for each global address, with the storage over the nodes randomized in a manner independent of the application program. Three additional operations, i.e. After, Wait and Remove, are defined to, respectively, allow a process to react to the completion of a timeout interval, allow a process to do nothing until other operations are completed, and allow housekeeping of obsolete variables. The initial (7/97) implementation of Counterpoint has a C++ programming interface. It must also be embedded in a system providing process scheduling and execution and which carries out communication between nodes. The first two capabilities are realized in a single UNIX process which runs on each node and provides a run-time system that is single-threaded and uses objects for processes. This makes processes cheap and process migration relatively easy. The communications are handled using the MPI library.

A source code distribution of the initial Counterpoint implementation is available. It is written in C++ and MPI and is being developed on a Linux Intel system. Documentation is provided both online and in the distribution.

[http://www.felinia.com/cpt/]

 

COUPLE

A Fortran 77 program which performs a stepwise coupled mode calculation of the 2-D underwater acoustic field due to a vertical array of harmonic point or line sources in, respectively, cylindrical or plane geometry. The environment can be range dependent, i.e. consist of a series of horizontally stratified fluid filled regions. Each region is assumed to have a piecewise linear depth variation in the index of refraction squared in the water and sediment layers as well as an exponential depth variation in the sediment density. The index of refraction in the sediment may be complex to allow for attenuation. The modal calculation in each of the regions is accomplished via a search or Galerkin procedure. The complex eigenvalues are found using a search procedure based on Newton's method if the water and sediment layers are homogeneous with only the depth varying with range. The Galerkin matrix method is used in the more general case of inhomogeneous water and sediment layers, range dependent material properties, and range dependent bathymetry. A decoupling algorithm is used to solve the matrix two-point boundary value problem in range which occurs in the stepwise coupled mode formulation, a procedure which eliminates the numerical instability that occurs with shooting methods.

A source code distribution of COUPLE is available. It is written in Fortran 77 and documented within an ASCII user's guide as well as via comment statements contained within the source code files. See Evans (1983), Evans (1986), and Evans and Gilbert (1985).

[ftp://oalib.njit.edu/pub/couple/]

 

COX

The C with Operator eXtensions is a language in which C has been extended in various ways to facilitate operator overloading and general object oriented programming. COX is upward compatible with C and supports a general operator concept. The language extension concepts include a general operator concept with almost arbitrary operator names and in which the meaning and precedence of operators may be overloaded. Argument and result types may also be overloaded and floating point literals have the additional result type char. Other features include a new data type aggregate, constructors and destructors, the possibility of different constructors and destructors for temporary variables, references, a distinction between read and write access of values, named loops, support for vector-like literals with typed open parameter lists, templates, attributed types for distinctive template overloading, and generic declarations using typeof(expression). The COX package is available in source code format or in binary form for Linux Intel, Sun Solaris, and OS/2 platforms. It is (rather sketchily thus far) documented in a user's guide in Texinfo and HTML formats.

[ftp://ti3sun.ti3.tu-harburg.de/pub/cox/]

 

cpio

A program to manage archives of files. This is the GNU version which supports the features of the System V release 4 cpio, including support for tar archives. This package also includes rmt, the remote tape server, and mt, a tape drive control program. The March 1996 issue of the Linux Journal has an article entitled ``cpio: A Multipurpose Archive Tool'' by Eric Goebelbecker (for which an online version is available). [http://www.gnu.ai.mit.edu/order/ftp.html]

 

cpp

The C PreProcessor is a macro processor used automatically by the GCC compiler to transform a program in various ways before it is compiled. The GNU cpp provides a superset of the features of ANSI Standard C. It is called a macro processor because it allows macros, i.e. brief abbreviations for longer constructs, to be defined. Four separate facilities can be used separately or in some combination. These are: the inclusion of header files containing declarations to be substituted into a program, the aforementioned macros, conditional compilation in which certain parts of a program can be included or excluded according to various conditions, and line control which can be used to inform the compiler of where each source line originally came from (if a program is used to combine or rearrange source files into an intermediate file). The GNU cpp is included in the GCC distribution and is automatically invoked whenever a program is compiled with it. It can also be invoked separately via the cpp command. It is documented in a user's manual available in standard Texinfo format. See also the separately available GNU m4 macro processor.

[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://sunsite.unc.edu/pub/Linux/GCC/ ]

 

cppf77

A package which implements a standard for portable, mixed C++/Fortran 77 programming. The requirements this package attempts to meet are that: the mixed programs must be as portable as their Fortran-only ancestors, a single source code must be used on all platforms, calling F77 from C++ must be easy and straightforward and not significantly more difficult than calling F77 from itself, mixed code must not induce any significant performance penalty, all major F77 features must be supported from C++, and calling F77 from C++ should be done without changing the F77 code. [http://home.sol.no/~arnholm/]

 

CppIma

A C++ library designed for image processing tasks. It is a way to provide an interface from C++ to common operations on images whose primary goal is to enable the easy construction of image processing programs. A secondary goal is to create an API independent of the actual image processing library used. To this end CppIma currently (3/97) suports three different image processing libraries: the ima library (of which a simple version is included in the CppIma package); the Khoros package library; and the SCIL-Image package library. The CppIma distribution includes the source code which is written in C++. It should compile with g++ as well as with Cfront-based compilers. The documentation is contained within a user's guide available in HTML format online.

[http://www.ph.tn.tudelft.nl/~klamer/cppima.html]

 

CPQR79

A Fortran routine which computes all zeros of a polynomial of arbitrary degree with complex coefficients by computing the eigenvalues of the companion matrix. A related routine called RPQR79 exists in the package for the case of real coefficients. This routine is an interface to an eigenvalue routine in the EISPACK library. This is part of CMLIB. [http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]

 

CPZERO

A package of Fortran subroutines for finding all the zeros of polynomials with either real or complex coefficients. The routine CPZERO is for complex and RPZERO for real coefficients. These programs also provide estimates of the errors in the estimates of the zeros. The method used is Newton's method applied to the system obtained by setting the polynomial coefficients equal to the symmetric functions of the roots. The source code for CPZERO is available. It is written in Fortran and its use is documented in comment statements within the source code. This is part of CMLIB.

[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]

 

CrackLib

A library containing C programs which attempt to prevent users from choosing easily guessed passwords by filtering them out at the source. It checks all the passwords in the password file against words in a dictionary that have been encoded with the same algorithm as were the passwords. The same original string as the password will encode into a string identical to that of the original password's encoding. It doesn't take modern computers very long to compare some really large dictionaries to the passwords in a file so this is a reasonably effective security technique. A version of this modified for shadow passwords can be found in the Shadow Ina Box tool suite. [http://sunsite.unc.edu/pub/Linux/system/admin/]

 

CRDtools

A collection of tools providing data extraction, analysis and visualization capabilities for the climate researcher. The file extraction tools include those for selecting datasets by attributes, adding entries to a data dictionary, reading and writing NetCDF format files, viewing the metadata for NetCDF files, and merging NetCDF files. The visualization tools include those for drawing an image using Xlib routines. Xlib is also used for drawing scrollable time graphs and scatterplots. Plots created using NCAR graphics include contour and time plots as well as graphs of spectra. Among the analysis tools available are those that compute annual data means and long-term composites, calculate correlation and regression coefficients, perform spectral analysis, perform arithmetic operations on multiple files, and perform smoothing and interplation of file data. The CRDtools software is written in C and Fortran. The source code is available as well as a binary for platforms running Sun Solaris. The source can be compiled on platforms with C and Fortran compilers as well as either OpenWindows or the XView library. The make file includes targets for Sun and Mips machines and can probably be modified without major effort to compile the thing on a Linux box, especially since the XView library is readily available in both source and binary form for Linux systems. The documentation is contained within several internal help files that can be used from within the system. See the CRDtools Installation Guide for instructions on how to obtain it.

[http://www.cdc.noaa.gov/cdc/crdtools/crdtools.html]

 

cryptography

Packages dealing with cryptography include:

• CryptoLib, a portable and efficient library of primitives for building cryptographic applications;
• Crypto++, a C++ class library of cryptographic primitives;
• FreeLIP, a large integer programming package for prototyping and experimenting with number theory-based cryptographic protocols;
• Kerberos, a network authentication system based on the key distribution model;
• MD5, a program that calculates a message-digest fingerprint or checksum for a file;
• PGP, a program for electronic mail privacy;
• premail, a program for the transparent encryption of email;
• Privtool, a PGP-aware replacement for the standard mailtool program;
• SECUDE, a security toolkit incorporating well-knonw symmetric and public-key cryptography;
• SESAME, a toolkit for building security infrastructure components using cryptographic protection;
• SSLeay, an implementation of the software encryption protocol of Netscape; and
• SSLRef, the Netscape implementation of its software encryption protocol.

 

CryptoLib

A portable and efficient library of primitives with which cryptographic applications can be built. It is intended for research and experimental use and is distributed without warranty or support. The functionality of CryptoLib includes:

• arbitrary length bignums;
• a bigmath package;
• many cryptographic primitives include DES, 3DES, Diffie-Hellman, DSA, El Gamal, Rabin, MD2, MD4, MD5, RSA and SHA; and
• support functions.

A source code distribution is available. It is written in C and can be compiled on most platforms.

[ftp://idea.sec.dsi.unimi.it/pub/security/crypt/math/]

 

Crypto++

A free C++ class library of cryptographic primitives. Crypto++ contains:

• symmetric block ciphers, e.g. IDEA, DES, DES-EDE, RC5, Blowfish, Diamond2, TEA, SAFER, 3-WAY, GOST, SHARK, CAST-128 and Square;
• generic cypher modes, e.g. CBC, CFB, OFB and counter mode;
• stream ciphers, e.g. SEAL, WAKE, Sapphire and BlumBlumShub;
• public key cryptography, e.g. RSA, DSA, ElGamal, Diffie-Hellman, BlumGoldwasser, Rabin, LUC, LUCDIF, LUCELG and Elliptic Curve Cryptosystems;
• padding schemes for public key systems, e.g. PKCS1, OAEP and PSSR;
• one-way hash functions, e.g. SHA, MD5, HAVAL, RIPE-MD160 and Tiger;
• message authentication codes, e.g. MD5-MAC, HMAC and XOR-MAC;
• hash functions as ciphers, e.g. Luby-Rackoff and MDC;
• pseudo-random number generators (PRNG), e.g. ANSI X9.17 appendix C and PGP's RandPool;
• Shamir's secret sharing and Rabin's information dispersal scheme;
• gzip-compatible compression and decompression;
• fast multi-precision integer operations;
• prime number testing and generation;
• various miscellaneous modules, e.g. base 64 coding and 32-bit CRC;
• a high-level interface for the above using a filter/pipeline paradigm and;
• benchmarks and validation testing.

A source code distribution of Crypto++ is available. The most recent (6/98) version (2.3) can be compiled using egcs. This can be found in the LIBS/wedai subdirectory at the source location indicated on the site.

[http://www.eskimo.com/~weidai/cryptlib.html]

 

Crystal Space

A 6 degrees-of-freedom 3-D engine based on the portal technology. The features include:

• a true 6 degrees-of-freedom engine with arbitrary sloped convex polygons;
• perspective correct texture mapping with interpolation every 16 pixels;
• mipmapping to minimize memory strain on the texture cache;
• support for loading GIF, TGA, PGN and JPEG textures;
• mapping a texture on a polygon in various ways including rotated, scaled and mirrored;
• moving objects and a script language to control the movements;
• transparent and semi-transparent textures;
• static lighting with shadows;
• configurable colored lighting;
• dynamic and dynamic moveable lighting;
• 3-D triangle mesh sprites with frame animation;
• support for 8- and 15/16-bit displays and for internal 24-bit textures with private colormaps for each texture;
• optional MMX support; and
• an ASCII world file format for easily redefining worlds.

A source code distribution of Crystal Space is available. It is written in C++ (with assembler optionally available). Documentation is still (6/98) a bit sketchy but a FAQ and some other information are available.

[http://www.geocities.com/SiliconValley/Horizon/3856/]

 

CSDP

The C library for SemiDefinite Programming is a library of routines which implement a predictor-corrector variant of the semidefinite algorithm of Helmberg, Rendl, Vanderbei, and Wolkowicz. This makes effective use of sparsity in the constraint matrices, includes support for both linear equality and linear inequality constraints, and also includes support for general sparse matrices. The code is written in C with Fortran subroutines used for linear algebra. The source code is available as is a user's manual in PostScript format. See also INCT, LMITOOL, MAXDET, SDPA, SDPpack, SDPSOL, and SP. [http://www.nmt.edu/ borchers/csdp.html]

 

Csound

A software sound synthesis package which reads some files containing various notation and creates a soundfile which is either stored on disk or played in real time. The two main files which are read by Csound contain the score and an orchestra. The score is an event list for scheduling events, and the orchestra defines how the events will be synthesized. An orchestra is composed of instruments which are processes triggered by the notes, i.e. events, in the score. The instruments in a Csound orchestra are defined in a simple syntax which invokes complex audio processing routines. Newer features of Csound include phase vocoder and FOF synthesis modules and a MIDI converter and control units which enable Csound to be run from MIDI score files as well as from external MIDI keyboards. The source code for Csound is available. It is written in mostly ANSI C and can be compiled on many generic UNIX platforms. The system is documented in a user's manual available in PostScript and HTML formats.

[http://www.leeds.ac.uk/music/Man/c_front.html]
[http://music.dartmouth.edu/~dupras/wCsound/csoundpage.html ]

 

CSS

Cascading Style Sheets are a style sheet mechanism designed specifically to allow Web designers and users set fonts, colors, white space, and other presentational aspects of a hypertext document. They allow authors and readers to influence the presentation of documents without sacrificing device-independence and without adding new HTML tags. The browsers which support CSS as of 5/97 include: Netscape Navigator 4.0, Emacs-w3, and (partially) Arena. An authoring tool which supports CSS is Amaya. [http://www.w3.org/pub/WWW/Style/]

 

CSSC

A workalike replacement for the SCCS (Source Code Control Suite) software package. It is a faithful reproduction of SCCS although some features, e.g. binary file support, are not yet (8/97) available. This test release contains a test suite and is aimed at getting CSSC tested on as many platforms as possible. It is recommended that new users try RCS rather than this since it is mainly intended as a drop-in replacement for SCCS. [ftp://alpha.gnu.ai.mit.edu/pub/gnu/CSSC/]

 

C*

An explicitly parallel language developed by Thinking Machines for which a compiler has been designed and built at the University of New Hampshire. The compiler translates C* code into C code plus calls to a communication library at points where data transfer among processors is required. The distribution includes the source code which is written in C. Documentation is separately available via several technical reports in PostScript format. The current (version 3) C* system should run on most UNIX workstations (including Linux). It also runs on networks of machines using PVM 3.x, the IBM SP-2, the nCUBE-2, and on multiprocessor Suns and DEC Alphas using multithreading. It will also run on Linux networks using the UNH Net* system (which is available in a subdirectory of the C* directory). Perl and an ANSI C compiler are needed to compile the system.

[ftp://ftp.cs.unh.edu/pub/cstar/]

 

Cthugha

An oscilloscope on acid, Cthugha is an oscilloscope program which takes a sound card's CD, line, or microphone input and displays it as a swirling, hypnotic, 256-color acid trip. The source code is available as are binaries for various platforms including Linux Intel. [http://www.afn.org/~cthugha/]

 

CtrlLAB

A Matlab-based control laboratory tool containing programs which provide a graphical interface for performing feedback system analysis and design tasks. The capabilities of CtrlLAB include: interactively entering models (including SIMULINK modeling); model display; system state space realization; model reduction using various algorithms; system analysis in frequency, complex, and time domains; graphical display and figure editing and manipulation; a matrix viewer and editor; and PID tuning and display facilities. The package is documented in 45 page user's manual in PostScript format. [ftp://ftp.mathworks.com/pub/contrib/v4/model/]

 

c2j

A C++ to Java translator which is available in versions written in both C++ and Java. See Laffra (1996). [http://members.aol.com/laffra/index.html]

 

c2j++

A C++ to Java translator based on c2j. [http://pacevm.dac.pace.edu:80/~ny971734/c2j.html]

 

Cubic Spline Library

A collection of C orutines that compute and manipulate cubic B-spline coefficinets under a variety of conditions. The routines handle two types of cubic splines, i.e. smoothing splines which fit the data in a least squares sense and interpolating splines which pass through specified points exactly. They also handle two types of boundary conditions, i.e. the natural spline where the curvature at the endpoints goes to zero and the periodic spline where the curve has the identical value, slope, and curvature at the endpoints. All routines are available in double and single precision, and some have Fortran callable interfaces. The CSL was created to provide a better method of searching astronomical photometric data for periodic behavior, and as such takes advantage of special B-spline features to perform a fast periodicity search. The CSL routines include those for computing B-spline function values, Fourier integrals of spline curves, constrained spline regression matrices, spline curvature derivative matrices, periodic smoothing splines, B-spline polynomial coefficients, B-spline first and second derivative coefficients, vector dot products, spline curve Fourier series, interpolating splines, inner products, spline least square error matrices, smoothing spline coefficients, periodic spline coefficients, integrals of the square of spline curves, periodic smoothing spline coefficients, period-folded spline curves, and spline curve values and slopes. There are also routines for allocating and deallocating data structures, searching for optimum smoothing spline parameters, Gauss-Jordan matrix inversion, finding spline curve minima and maxima, solve real positive definite band matrix systems, performing fine gridded frequency searches, performing indexed heapsorts, and more.

A source code distribution of the CSL is available. All routines are written in ANSI C and are documented internally as well as in some external papers and reports. See Akerlof et al. (1994).

[http://www-personal.umich.edu/~akerlof/cubic-spline/index.html]

 

CTC

A collection of PGP-compatible C routines that provides all the cryptographic, compression and file formatting functions needed to write PGP-compatible applications. CTC development goals included interoperability with PGP, machine and compiler independence, extensibility, a minimum of license and patent restrictions, modularity, and ease of auditing. The library consists of a set of separate modules including application callable modules, internal modules, and machine dependent modules. The CTC application callable modules are, as the name suggests, the ones that should be called by applications. They include:

• armour, which provides ASCII-armor coding and decoding;
• bignums, which provides multiple precision positive integer arithmetic;
• keyhash, which provides key management; and
• ctc, which provides high-level encryption and decryption functions.

The internal modules should not be used for direct calling from applications. They include cipher-control modules, which control which algorithms are executed at run-time. The machine dependent modules are those that need to be provided by the application. These modules provide user interaction and condition reporting functions, file access, true random number generation, and user interrupt detection. Standard C implementations of these are provided in the package.

A source code distribution of CTC is available. A user's manual is included in the distribution.

[http://www.bifroest.demon.co.uk/ctc/]
[http://www.geocities.com/SiliconValley/1394/ ]

 

Cthreads

A user-level threads package that runs on several uniprocessors and multiprocessors. Cthreads offers support for shared-memory parallel programming. A source code distribution of Cthreads is available which has been successfully installed on several platforms including Linux Intel. Several technical reports are available as documentation. [http://www.cc.gatech.edu/systems/projects/Cthreads/]

 

CTWM

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

• optional 3-D window titles and borders;
• simultaneous existence of windows in selectable workspaces;
• a workspace map to allow quick movement among them;
• animated widgets and root backgrounds;
• pinnable and sticky menus;
• optional state-aware m4 preprocessing of the .ctwmrc init file;
• uses on the standard X11 libraries;
• a documented and backwards-compatible superset of TWM; and
• full, tabbed, or no titlebars per window.

A source code distribution is available that is easily compiled on standard UNIX/X11 platforms.

[http://cqi.com/~humbubba/ctwm/ctwm.html]

 

CuPit

A programming language specifically designed to express neural network learning algorithms. It provides most of the flexibility of general-purpose languages like C, but results in much clearer and more elegant programs due to higher expressiveness, in particular for algorithms that change network topology dynamically (constructive algorithms, pruning algorithms). Furthermore, CuPit-2 programs can be compiled into efficient code for parallel machines; no changes are required in the source program. CuPit language features include:

• an object centered description of network topology,
• special data types (e.g. CONNECTION, NODE, NETWORK),
• parallel procedure calls,
• automatic reductions,
• winner-takes-all functions,
• the dynamic creation/deletion of connections/nodes,
• the capability to create network replicates and merge them into a single network,
• PASCAL-like syntax (e.g. procedures, static typing),
• access to external procedures/functions,
• special I/O variables e.g. for I/O of example patterns, and
• a complex interface for I/O of complete networks.

Compilers are available for sequential and symmetric multiprocessor (SMP) machines and they translate to C (with thread library calls for SMP). The library reads or writes networks as well as pattern files in SNNS formats.

The source code for the compiler is available and has been tested under Sun SunOS, DEC Alpha and Linux Intel platforms. It can be compiled using the ELI compiler construction system, installed as a binary for some platforms (of which one is not yet Linux), or compiled from the generated C source (from the ELI tools). Documentation is available in the form of a language reference and tutorial in PostScript format. A small collection of examples is also available.

[http://wwwipd.ira.uka.de/~hopp/cupit.html]

 

curl

A tool for automatically creating the links between the pages of a Web document. Curl uses the metaphor of a book to organize pages, with a typical situation having each page linked to its nearest siblings, its parent, and the top page of the document. Pages can contain two kinds of content lists and there are special pages for lists of links to keywords, figures, tables and new pages. There is also search engine available from every page. A source code distribution of curl is available. [http://www.cs.mu.oz.au/~ad/curl/announce.html]

 

Curl

A language for creating web documents with nearly any type of content from formatted text to complex interactive applets. Curl provides a rich set of formatting operations similar to those implemented with HTML tags, although unlike HTML it can be extended by users to provide additional functionality ranging from simple macros to direct control over the positioning of subcomponnets. The Curl project is currently (10/97) developing several packages of useful formatting extensions. Interactive interfaces can be easily built using a Tk-like interface toolkit consisting of various interactive components. The Curl object-oriented programming language can be used to developed almost any sort of sophisticated mechanism in an interactive web document. The Curl expressions embedded in the document are securely compiled into native code by a built-in on-the-fly compiler and then executed without the need for an interpreter. The language features include multiple inheritance, extensible syntax, a strong type system, safe execution via encapsulation of user code, and extensive checking at both compile and run time. The Curl system and compiler are mostly written in Curl. Binary versions of Curl are available for Sun SunOS, WIN32, and Linux Intel platforms. A source code distribution is also available. The documentation includes an online white paper and various documents contained within the distribution.

[http://cag-www.lcs.mit.edu/curl/]

 

CURSA

A Starlink Project package containing utilities for manipulating astronomical catalogues and similar tabular datasets. It provides facilities for browsing or examining catalogs, selecting subsets from a catalog, sorting catalogs, copying catalogs, and pairing two catalogs. CURSA can access catalogs in the FITS table format, the Small Text List (STL) format, or the CHI/HDS format used by the CATPAC catalog manipulating applications package. Allowable expressions for manipulating catalogs include arithmetic, relational, and boolean operators, bracketr, sexagisimal values (for degrees, hours, minutes, etc.), and great circle distances. A binary version of the CURSA package is available for Linux Intel, DEC OSF/1, and Sun Solaris platforms. A 66 page user's manual is available in PostScript format.

[http://star-www.rl.ac.uk/store/storeapps.html]

 

curses

See ncurses.

 

CUTE

The Constrained and Unconstrained Testing Environment is a suite of Fortran subroutines, scripts and test problems for linear and nonlinear optimization problems. Its purpose is to provide a way to explore an extensive collection of problems (800 different test problems so far), a way to compare existing packages, a way to use a large test problem collection with new packages, motivation for building a meaningful set of interesting new problems, ways to manage and update the system efficiently, and to do all the above on a variety of platforms. The CUTE package source code is available. It is written in Fortran 77 and single and double precision versions are available. Machine dependencies are carefully isolated and easily adaptable. There are standard installation scripts for many platforms and a Matlab version is available. There is as yet (3/97) no installation script for Linux platforms but it shouldn't be too tricky getting this going with the Linux/g77 combination. The documentation is contained within a user's guide available in PostScript format. See Bongartz et al. (1995).

[http://www.dci.clrc.ac.uk/Activity.asp?CUTE]

 

CVAP

The Computational Vision and Active Perception Lab software is is a distribution of several C software packages which perform tasks specific to computer vision studies as well as more general tasks which underlie them. The components of CVAP include:

• Exception, an ANSI C exception system;
• Opts, an advanced command line option parser which not only parses the command line but also converts the strings to C variable values;
• Candela, an image processing system whose kernel contains data types representing 2-D imaes with integer or floating point pixels, image I/O, and utilities for printing information about the images;
• Candisp, which provides support for displaying Candela images in various formats (e.g. PostScript, Abekas, TIFF, etc.);
• Canapp is the Candela Application Library containing library functions and programs for image processing;
• XOR++, an XOR (external object representation) interface to C++ which supports persistent objects in C++;
• OPTIC, an Object Program Tools In C package which consists of macros which support classes, inheritance, and virtual functions in C as well as a C interface to XOR;
• OPTICAL, an OPTIC Application Library containing a set of classes such as parameterized curves, polygons, points, and matrices as well as the Lux classes which provide an object oriented interface to Candela;
• Sequences, a library and utilities to manage collections of data files;
• Resedit, an interactive editor for Xt resources based on the GNU readline library; and
• Image is a set of image display widgets and objects whose features include modularity and extensibility, support for overlays, and advanced color support.

Separate source code distributions of all of the CVAP packages are available, and some require others to work properly. They are all written in ANSI C and can be compiled and used on several types of UNIX platforms using the supplied configure script. Documentation for each package is contained in each package to a greater or lesser extent.

[http://www.bion.kth.se/software.html]

 

CViz

A visualization tool for clustering and analysis of multi-dimensional data sets. It is most readily applicable to data sets containing between 100 and 50,000 examples where each example has between 2 and 200 mostly numerical components (dimensions) each describing a different attribute of the data. Optionally, each example may be provided with a classification value, indicating what class it belongs to. Ideally, there should be between 2 and 20 different nominal classes in the entire data set. It is most valuable when applied to situations where little or no information is known about the relationships between attributes and class or between different attributes. CViz gives the data analyst a unique tool for viewing the entire set of data points across the most interesting dimensions in a short period. CViz uses a k-means clustering algorithm to find interesting concepts in the data. It then draws 2-D scatter plots by selecting pairs or triples of concepts and relating these concepts to the data examples and the other concepts. By using an animation technique called touring, it allows the analyst to quickly cycle through all the different pairs or triples of concepts and see how the data changes from one perspective to another. This can often provide a unique insight into underlying structure of the data. A source code distribution of CViz is available. It is written in Java.

[http://www.alphaWorks.ibm.com/formula/CViz]

 

CVM

The Coherent Virtual Machine is a distributed shared memory (DSM) system. A very early release of the software is available (4/97) although this is an ongoing project. The goals of CVM include: multiple protocol support with the initial configuration file providing four memory models, i.e. single- and multiple-writer versions of lazy release consistency, sequential consistency, and eager release consistency; extensibility in that the source will be freely available and the modules are written in C++; multi-threading support which will allow overlap of computation and communication through context switching; and fault tolerance sufficient to allow the system to recover from at least one node failure at a time. [http://www.cs.umd.edu/projects/cvm/]

 

Cvo

C++ Visual Objects is a toolkit for the building of visual tools for the X Window system. It is written in C++ and visually resembles the Motif toolkit but there are significant differences between Cvo and other toolkits. These differences or features include an object oriented design, executables typically 2 to 4 times smaller than those compiled using other tookits, less code to write per application, a smaller and more consistent set of interfaces, and applications that are (due to the above reasons) inherently more maintainable. Another major feature of Cvo is that it takes advantage of the internationalization features inherent in X11R5 and later releases. A rich set of visual objects is provided, including the standard things like buttons, text displays, input boxes, pop-up and pull-down menus, scrolling lists, and radio boxes. More specialized objects such as a chart object that expands to support 3-D and pie charts and a canvas on which an application may paint are also included. New complex objects may be easily constructed using existing objects as bulding blocks due to the object oriented nature of the toolkit. Cvo also attempts to consolidate similar concepts within a single method, e.g. "callback" functions are treated like any other "event" which reduces not only the complexity of the system but also the amount of information an application writer needs to remember to use it.

Cvo was created as an internal Cray Research Inc. project but, due to various reasons unrelated to its utility, made freely available subject to a fairly permissive copyright notice. Extensive documention is included with the distribution including a tutorial in PostScript and hypertext documentation of the visual objects in the toolkit. There are several makefiles for various architectures and Cvo will build using GCC/G++, making it amenable for compilation and use on Linux platforms

[ftp://ftp.x.org/contrib/libraries/]

 

CVS

A version control system which can record the history of a set of source files. CVS keeps track of old versions of files in an efficient manner by storing only the differences between successive versions. It also allows groups of people working on the same file to separately make changes, merging all the changes only when each developer is done. It keeps track of revisions by giving each file in the revision tree a unique revision number, and allows revision trees to be split into separate branches with each a self-maintained line of development that can be easily merged back into the main trunk. All files and directories under version control are stored in a repository which is almost always accessed via CVS commands rather than directly. CVS is a complex program with many features and capabilities. A source code distribution of CVS is available. It is written in C and can be compiled and used on many types of platforms using the configure script supplied in the distribution. It is documented in a 120 page user's manual available in Texinfo format.

[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://www.cyclic.com/ ]

 

CurVeS

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

CVS Build System

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

• utilities to simplify the creation of initial modules and module tagging;
• configuration management for groups of modules called products;
• utilities to automate checking out, branching and merging of products in one operation; and
• an integrated build system for products.

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

 

cvs-track

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

• track, the main program;
• cvs-cmp, a helper program for track that comparies a working directory to a repository; and
• cvs-move, which allows you to move CVS-controlled files in a couple of ways.

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

 

CVS Web

A utility to create and browse CVS trees via the Web. [http://www.freebsd.org/~fenner/cvsweb/]

 

cvslines

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

• helps solve the ``you must remember to do it'' problem by forcing the issue;
• promotes doing the merge now rather than putting it off;
• guides a user through the correct sequence of CVS commands needed to merge changes from one development line to another; and
• helps to eliminate the creation of unneeded RCS branches until they're needed.

A source code distribution of cvslines is available. It is written in C and documented in a man page.

[http://www.netapp.com/technology/freeware/cvslines/]

 

cvs2html

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

 

gCVS

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

[http://dsg.harvard.edu/public/software/gcvs/]

 

tkCVS

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

• a file and directory browser with optional display of hidden files and display of the current directory's location within the CVS tree;
• pushbutton-based check-in and check-out of CVS modules with the ability to add and delete files using pushbuttons;
• a module tree browser and reports showing the structure of the CVS modules tree;
• updating of files from the repository when they change;
• tagging and branching of files from the file browser;
• tagging and branching of modules from the module browser;
• exporting a CVS module or directory from the respository for delivery offsite;
• creation of patch files between two releases of a module or between a release and the current version; and
• viewing of diff and status listing for currently checked out modules.

A source code distribution of tkCVS is available. It supports CVS versions before 1.3 but 1.6 is recommended. The most recent release also requires Tk version 4.0.

[http://www.NeoSoft.com/tcl/ftparchive/sorted/apps/tkcvs-6.0/]

 

CWEB

A software system that facilitates the creation of readable programs, i.e. a literate programming system. WEB was originally developed by Donald Knuth as he wrote the TeX typesetting system. The use of WEB allows users to write programs of superior quality, produce state-of-the-art documentation, greatly reduce debugging time, and easily maintain programs as conditions change. A CWEB source file contains text and commands that allow it to be processed to obtain either a program in one of several programming languages or the documentation for that program in TeX format. CWEB is a version of WEB for documenting C, C++, and Java programs. The CWEB program is fully documented in Knuth (1993) and is freely available at the given URL. The software consists of two programs: CTANGLE, which converts a source file to a compilable program source code file; and CWEAVE, which converts a source file to a TeX source code document. See also Knuth (1992). [ftp://labrea.stanford.edu/pub/cweb/]

 

CWEBx

A modified implementation of the CWEB literate programming system for the ANSI C language and plain TeX output. CWEBx has a full compatibility mode with CWEB as well as some extensions including typedef declarations that globally affect formatting in the source file, scanning of include files for typedef definitions, flexible selection of layout style, referring to sections using symbolic labels, a new and modular set of grammar rules based on ANSI C syntax, and a new manual. [http://wallis.univ-poitiers.fr/~maavl/CWEBx/]

 

CWP/SU

This description has been moved to SU.

 

Cxref

A program which inputs a series of C source files and outputs a LaTeX or HTML document containing a cross reference of the files, functions, and variables in the program, including documentation taken from suitably formatted comments in the source code. The documentation is stored within the C source code in a specially formatted comments. The cross referencing includes lists of functions called, callers of each function, usage of global variables, header file inclusion, macro definitions, and type definitions. The works with ANSI C including many gcc extensions. [http://sunsite.unc.edu/pub/Linux/devel/lang/c/]

 

CyberRadio

A software package for broadcasting radio programming across the Internet. It is intended to supply intranets and radio stations with a fast connection to the Internet something on which to broadcast their sound. CyberRadio is a client/server system in which the server continually reads digital data from the audio device (e.g. /dev/audio) and multiplexes it to any number of connected clients. The connected clients play the audio out of their audio devices. The distribution contains a server program, a client program, a server utility program that displays current client/server connection information, other utility programs to manage connections including a sample program that can send text messages to clients, a special version of the client program and shell script that sends short samples of audio data over the WWW as a CGI bin porgram, and protocol and packet format specifications. A source code distribution of CyberRadio is available for UNIX platforms. It is written in C and should compile on almost any UNIX system, including Linux.

[http://www.cis.ufl.edu/~jselbie/cr1.html]

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z

[ home / linux ]