Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Concept:Library]] was answered by the SMWSQLStore3 in 0.0549 seconds.


Results 61 – 110    (Previous 50 | Next 50)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


BRL-CAD
BRL-CAD includes an interactive geometry editor, parallel ray-tracing support for rendering and geometric analysis, path-tracing for realistic image synthesis, network distributed framebuffer support, image-processing and signal-processing tools.
Babel
A collection of tools for internationalizing Python applications Babel is composed of two major parts:
  • tools to build and work with gettext message catalogs
  • a Python interface to the CLDR (Common Locale Data Repository), providing access to various locale display names, localized number and date formatting, etc.
Backbone.js
Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface.
Badger
Badger is a library used to generate badge sheets for events, given a PDF template and data for the badges.
Barcode Heckert gnu.tiny.png
GNU barcode is a tool to convert text strings to printed bars. It supports a variety of standard code to represent the strings and creates postscript output. Features include:
  • available as both a library and a command line frontend (so you can include barcode printing in your application)
  • supports UPC, EAN, ISBN, CODE39, and other encoding standards
  • Postscript and encapsulated postscript output (other backends can be added as needed)
  • Accepts sizes and positions as inches, millimeters, and centimeters
  • Can create tables of barcodes (to print labels on sticker pages)
Bcfg2
Bcfg2 allows you to describe and deploy complex configurations across pools of GNU/Linux and Unix systems, leading to a consistent, reproducible, and verifiable description of your environment. Bcfg2's visualization and reporting tools aid in your day-to-day administrative tasks. Its unique analysis features help you cope with the ever-increasing complexity of your networks.
Beanstalkc
beanstalkc is a simple beanstalkd client library for Python. beanstalkd is a fast, distributed, in-memory workqueue service.
BeeCrypt
BeeCrypt is a cryptography library that contains highly optimized C and assembler implementations of many well-known algorithms including Blowfish, MD5, SHA-1, Diffie-Hellman, and ElGamal. Unlike some other crypto libraries, BeeCrypt is not designed to solve one specific problem, like file encryption, but to be a general purpose toolkit which can be used in a variety of applications. There are also no patent or royalty issues associated with BeeCrypt.
Bennu
Bennu is a software library written in PHP that implements the functionality of the IETF iCalendar 2.0 specification (RFC 2445). Its purpose is to enable applications which have an interest in this format (e.g. calendaring, scheduler and organizer programs) to support iCalendar in an easy, powerful, and extensible way.
BigMath
Based partly on Knuth's Seminumerical Algorithms and written in C, BigMath aims to be light-weight and fast. Its original implementation was for use within a kernel extension - thus size and speed were essential. BigMath supports only integer math, including add, sub, mul, div, mod, modpow, modinv, pow, gcd, factorial, radix conversion, scientific notation and various comparisons.
Bill's OpenGL Library
BOGL - an OpenGL scenegraph/renderer supporting modern hardware (vertex and pixel programs via Cg, buffer objects, etc), freetype fonts, XML resource files, bezier patches, state sorting, separate render and simulation threads.
Binary I O library
'libbinio' uses its own protocol to store and retrieve binary data portably. It uses an fprintf/fscanf interface, exporting eight functions: fputf, vfputf, fgetf, vfgetf, fwputf, vfwputf, fwgetf, and vfwgetf. Rather than using data types such as "16 bits", it uses standard C types and uses printf/scanf-style argument lists (it even uses GNU argument checking if available). It should be a drop-in replacement for printf/scanf and still work perfectly well. It aims to be portable to every C89-conforming implementation, but can use C99 and GNU extensions if available.
Bioinformatics Template Library
This library focuses on the data structures and algorithms used in bioinformatics and molecular modelling, following closely the approach of the Standard Template Library (STL) to implement efficient generic programming modules using compile time mechanisms. Although the BTL was designed with biomolecular applications in mind it contains classes of more general utility: for instance, the Matrix class could be used for matrix algebra in many contexts.
BirdFont
BirdFont is a font editor which can generate fonts in SVG, EOT and TTF format.
Biskit
Biskit is a python library for structural bioinformatics research. It simplifies the analysis of macromolecular structures, protein complexes, and molecular dynamics trajectories and offers a platform for the rapid integration of external programs.
Bit Vector
Bit::Vector is a (stand-alone) C library and an object-oriented Perl module (with overloaded operators) which allows you to handle bit vectors, sets (of integers), "big integer arithmetic" (e.g. for cryptography), and boolean matrices (all of arbitrary size) very efficiently. The package also includes an object-oriented Perl module for accessing the C library from Perl (the library can also be used by itself, without Perl). Optionally, it features overloaded operators for maximum ease of use.
BitPacket
BitPacket is a Python module to represent bit field structures in an easy object-oriented way. BitPacket provides three classes: BitField, BitStructure and BitVariableStructure which represent simple bit fields, and fixed and variable structures of bit fields respectively. BitStructure and BitVariableStructure are BitField themselves and all of them can be used together in order to build packets. That is, we can add any BitField subclass into a BitStructure or BitVariableStructure.
Bitap
The bitap library is a clean implementation of regular expression (regex/grep) string matching using the bitap algorithm. Approximate (a.k.a. fuzzy) matching is allowed. This is the same algorithm as the one used in Glimpse and agrep, but it is much more complete with regard to regular expression syntax, and is much cleaner. It is quite fast compared to other greps due to the bitap algoritm and modern CPU architechture. Modifying code for special cases speeds things up even futher. Note that the complete 'search' string must be matched by the pattern. If you want to search for substrings of the search string, prefix and postfix the pattern with '.*'.
Bitstring
bitstring is a pure Python module designed to help make the creation and analysis of binary data as simple and natural as possible. BitStrings can be constructed from integers (big and little endian), hex, octal, binary, strings or files. They can be sliced, joined, reversed, inserted into, overwritten, etc. with simple functions or slice notation. They can also be read from, searched and replaced, and navigated in, similar to a file or stream.
Bitwise enums
A very simple, 0-overhead, and yet type-safe 1-file library for doing bitwise operations between masks represented by enums. Please note: This library has been subsumed into MiLi and is no longer being maintained individually.
Blib
'blib' is the Blinkenlights Library, a programming library that gives you a kick start into development with Blinkenlights/Arcade. 'blib' also provides the Game API with which games for Arcade can be developed. 'blib' provides functions to read and write BLM, BML, and MNG animations, and to receive and send the Blinkenlights protocol.
Blip Buffer
Blip_Buffer implements efficient band-limited sound synthesis buffers, allowing high-quality emulation of video game sound chips. After setting the source clock rate and output sampling rate, waveforms are generated by specifying the time points where amplitude changes occur. Treble and bass adjustments are also supported. Many examples are included that show basic waveform generation, sample buffering schemes, and more advanced topics. They can be made to write output to a wave sound file, or optionally use the SDL multimedia library for real-time playback, waveform display, and mouse control of parameters.
BlockCanvas
The BlockCanvas project provides a visual environment for creating simulation experiments, where function and data are separated. Thus, you can define your simulation algorithm by visually connecting function blocks into a data flow network, and then run it with various data sets (known as "contexts"); likewise, you can use the same context in a different functional simulation. The project provides support for plotting, function searching and inspection, and optimization. It includes a stand-alone application that demonstrates the block-canvas environment, but the same functionality can be incorporated into other applications. The BlockCanvas project relies on included libraries that allow multiple data sets using Numeric arrays to be incorporated in a Traits-based model in a way that is simple, fast, efficient, and consistent.
Bmrblib
Bmrblib is a Python API abstracting the Biological Magnetic Resonance Data Bank (BioMagResBank or BMRB) NMR-STAR format (http://www.bmrb.wisc.edu/). It allows the writing of NMR-STAR files for BMRB data deposition and the reading and easy extraction of data from files residing in the BMRB data bank, all without knowledge of the Self-Defining Text Archive and Retrieval (STAR) format.
Boehm garbage collector
A conservative garbage collector which can be used as a garbage collecting replacement for C malloc or C++ new and as a malloc leak detector.
Bond
BOND (building object network databases) is a rapid application development tool which allows you to develop GUI front ends to PostgreSQL databases. It uses XML to define widget layout and how to obtain information from databases. This project is designed to simplify the process of developing database applications for GTK.
Booleano
Booleano is an interpreter of boolean expressions, a library to define and run filters available as text (e.g., in a natural language) or in Python code. In order to handle text-based filters, Booleano ships with a fully-featured parser whose grammar is adaptive: Its properties can be overridden using simple configuration directives.
Boost
Boost is a repository of portable and peer-reviewed C++ libraries.
Accumulators 
Framework for incremental calculation, and collection of statistical accumulators. Math and numerics
Algorithm 
A collection of useful generic algorithms. Algorithms
Any 
Safe, generic container for single values of different value types. Data structures
Array 
STL compliant container wrapper for arrays of constant size. Containers
Asio 
Portable networking, including sockets, timers, hostname resolution and socket iostreams. Concurrent Programming
Assign 
Filling containers with constant or generated data has never been easier. Input/Output
Bimap 
Bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key. Containers
Bind 
boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions. Function objects and higher-order programming
Call Traits 
Defines types for passing parameters. Generic Programming
Chrono 
Useful time utilities. Domain Specific
Circular Buffer 
A STL compliant container also known as ring or cyclic buffer. Containers
Compatibility 
Help for non-conforming standard libraries. Broken compiler workarounds
Compressed Pair 
Empty member optimization. Data structures
Concept Check 
Tools for generic programming. Generic Programming
Config 
Helps Boost library developers adapt to compiler idiosyncrasies; not intended for library users. Broken compiler workarounds
Container 
Standard library containers and extensions. Containers
Context 
Context switching library. Concurrent Programming
Conversion 
Polymorphic and lexical casts. String and text processing
CRC 
The Boost CRC Library provides two implementations of CRC (cyclic redundancy code) computation objects and two implementations of CRC computation functions. The implementations are template-based. Domain Specific
Date Time 
A set of date-time libraries based on generic programming concepts. Domain Specific
Dynamic Bitset 
The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset. Containers
Enable If 
Selective inclusion of function template overloads. Generic Programming
Exception 
The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads. Language Features Emulation
Filesystem 
The Boost Filesystem Library provides portable facilities to query and manipulate paths, files, and directories. System
Flyweight 
Design pattern to manage large quantities of highly redundant objects. Patterns and Idioms
Foreach 
In C++, writing a loop that iterates over a sequence is tedious. We can either use iterators, which requires a considerable amount of boiler-plate, or we can use the std::for_each() algorithm and move our loop body into a predicate, which requires no less boiler-plate and forces us to move our logic far from where it will be used. In contrast, some other languages, like Perl, provide a dedicated "foreach" construct that automates this process. BOOST_FOREACH is just such a construct for C++. It iterates over sequences for us, freeing us from having to deal directly with iterators or write predicates. Algorithms
Format 
The format library provides a class for formatting arguments according to a format-string, as does printf, but with two major differences: format sends the arguments to an internal stream, and so is entirely type-safe and naturally supports all user-defined types; the ellipsis (...) can not be used correctly in the strongly typed context of format, and thus the function call with arbitrary arguments is replaced by successive calls to an argument feeding operator%. String and text processing
Function 
Function object wrappers for deferred calls or callbacks. Function objects and higher-order programming
Function Types 
Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types. Generic Programming
Functional 
The Boost.Function library contains a family of class templates that are function object wrappers. Function objects and higher-order programming
Functional/Factory 
Function object templates for dynamic and static object creation Function objects and higher-order programming
Functional/Forward 
Adapters to allow generic function objects to accept arbitrary arguments Function objects and higher-order programming
Functional/Hash 
A TR1 hash function object that can be extended to hash user defined types. Function objects and higher-order programming
Functional/Overloaded Function 
Overload different functions into a single function object. Function objects and higher-order programming
Fusion 
Library for working with tuples, including various containers, algorithms, etc. Template Metaprogramming
Geometry 
Geometry Library. Algorithms
GIL 
Generic Image Library Containers
Graph 
The BGL graph interface and graph components are generic, in the same sense as the the Standard Template Library (STL). Containers
Heap 
Priority queue data structures. Data structures
ICL 
Interval Container Library, interval sets and maps and aggregation of associated values Containers
Identity Type 
Wrap types within round parenthesis so they can always be passed as macro parameters. Preprocessor Metaprogramming
In Place Factory, Typed In Place Factory 
Generic in-place construction of contained objects with a variadic argument-list. Generic Programming
Integer 
The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std. Math and numerics
Interprocess 
Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators. Concurrent Programming
Interval 
Extends the usual arithmetic functions to mathematical intervals. Math and numerics
Intrusive 
Intrusive containers and algorithms. Containers
IO State Savers 
The I/O sub-library of Boost helps segregate the large number of Boost headers. This sub-library should contain various items to use with/for the standard I/O library. Input/Output
Iostreams 
Boost.IOStreams provides a framework for defining streams, stream buffers and i/o filters. String and text processing
Iterators 
The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors. Iterators
Lambda 
Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Lexical Cast 
General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney. String and text processing
Local Function 
Program functions locally, within other functions, directly within the scope where they are needed. Function objects and higher-order programming
Locale 
Provide localization and Unicode handling tools for C++. String and text processing
Math 
Boost.Math includes several contributions in the domain of mathematics: The Greatest Common Divisor and Least Common Multiple library provides run-time and compile-time evaluation of the greatest common divisor (GCD) or least common multiple (LCM) of two integers. The Special Functions library currently provides eight templated special functions, in namespace boost. The Complex Number Inverse Trigonometric Functions are the inverses of trigonometric functions currently present in the C++ standard. Quaternions are a relative of complex numbers often used to parameterise rotations in three dimentional space. Octonions, like quaternions, are a relative of complex numbers. Math and numerics
Math Common Factor 
Greatest common divisor and least common multiple. Math and numerics
Math Octonion 
Octonions. Math and numerics
Math Quaternion 
Quaternions. Math and numerics
Math/Special Functions 
A wide selection of mathematical special functions. Math and numerics
Math/Statistical Distributions 
A wide selection of univariate statistical distributions and functions that operate on them. Math and numerics
Member Function 
Generalized binders for function/object/pointers and member functions. Function objects and higher-order programming
Meta State Machine 
A very high-performance library for expressive UML2 finite state machines. State Machines
Min-Max 
Standard library extensions for simultaneous min/max and min/max element computations. Algorithms
Move 
Portable move semantics for C++03 and C++11 compilers. Language Features Emulation
MPI 
Message Passing Interface library, for use in distributed-memory parallel application programming. Concurrent Programming
MPL 
The Boost.MPL library is a general-purpose, high-level C++ template metaprogramming framework of compile-time algorithms, sequences and metafunctions. It provides a conceptual foundation and an extensive set of powerful and coherent tools that make doing explict metaprogramming in C++ as easy and enjoyable as possible within the current language. Template Metaprogramming
Multi-Array 
Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface. Containers
Multi-Index 
The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics. Containers
Numeric Conversion 
Optimized Policy-based Numeric Conversions. Math and numerics
Operators 
Templates ease arithmetic classes and iterators. Iterators
Optional 
Discriminated-union wrapper for optional values. Miscellaneous
Parameter 
Boost.Parameter Library - Write functions that accept arguments by name. Programming Interfaces
Phoenix 
Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Pointer Container 
Containers for storing heap-allocated polymorphic objects to ease OO-programming. Containers
Polygon 
Booleans/clipping, resizing/offsetting and more for planar polygons with integral coordinates. Miscellaneous
Pool 
Memory pool management. Memory
Preprocessor 
Preprocessor metaprogramming tools including repetition and recursion. Preprocessor Metaprogramming
Program Options 
The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file. Input/Output
Property Map 
Concepts defining interfaces which map key objects to value objects. Containers
Property Tree 
A tree data structure especially suited to storing configuration data. Containers
Proto 
Expression template library and compiler construction toolkit for domain-specific embedded languages. Template Metaprogramming
Python 
The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler. Inter-language support
Random 
A complete system for random number generation. Math and numerics
Range 
A new infrastructure for generic algorithms that builds on top of the new iterator concepts. Algorithms
Ratio 
Compile time rational arithmetic. Math and numerics
Rational 
A rational number class. Math and numerics
Ref 
A utility library for passing references to generic functions. Function objects and higher-order programming
Regex 
Regular expression library. String and text processing
Result Of 
Determines the type of a function call expression. Function objects and higher-order programming
Scope Exit 
Execute arbitrary code at scope exit. Language Features Emulation
Serialization 
Serialization for persistence and marshalling. Input/Output
Signals 
Managed signals & slots callback implementation. Function objects and higher-order programming
Signals2 
Managed signals & slots callback implementation (thread-safe version 2). Function objects and higher-order programming
Smart Ptr 
Smart pointer class templates. Memory
Spirit 
LL parser framework represents parsers directly as EBNF grammars in inlined C++. String and text processing
Statechart 
Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code. State Machines
Static Assert 
Static assertions (compile time assertions). Generic Programming
String Algo 
String algorithms library. String and text processing
Swap 
Enhanced generic swap function. Miscellaneous
System 
Operating system support, including the diagnostics support that will be part of the C++0x standard library. System
Test 
Support for simple program testing, full unit testing, and for program execution monitoring. Correctness and testing
Thread 
Portable C++ multi-threading. Concurrent Programming
Timer 
Event timer, progress timer, and progress display classes. Miscellaneous
Tokenizer 
Break of a string or other character sequence into a series of tokens. String and text processing
TR1 
The TR1 library provides an implementation of the C++ Technical Report on Standard Library Extensions. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1. Miscellaneous
Tribool 
3-state boolean type library. Miscellaneous
Tuple 
Ease definition of functions returning multiple values, and more. Data structures
Type Traits 
Templates for fundamental properties of types. Generic Programming
Typeof 
Typeof operator emulation. Language Features Emulation
uBLAS 
uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported. Math and numerics
Units 
Zero-overhead dimensional analysis and unit/quantity manipulation and conversion. Domain Specific
Unordered 
Unordered associative containers. Containers
Utility 
Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom. Algorithms
Uuid 
A universally unique identifier. Data structures
Value Initialized 
Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams. Miscellaneous
Variant 
Safe, generic, stack-based discriminated union container. Containers
Wave 
The Boost.Wave library is a Standards conformant, and highly configurable implementation of the mandated C99/C++ preprocessor functionality packed behind an easy to use iterator interface. String and text processing
Xpressive 
Regular expressions that can be written as strings or as expression templates, and which can refer to each other and themselves recursively with the power of context-free grammars. String and text processing
Boost Numeric Bindings
Boost Bindings is a bindings library (not just) for Boost.Ublas. It offers an easy way of calling BLAS, LAPACK, UMFPACK, MUMPS and many other mature legacy numerical codes from within C++.
Bootstrap
Bootstrap is a mobile-first, responsive Web front-end framework. It is a very popular framework made by Twitter, and can be easily themed and customized.
Bootswatch
Bootswatch is a set of free themes for Bootstrap.
Botan
Botan (formerly OpenCL) is a library of cryptographic algorithms. It includes a wide selection of block and stream ciphers, public key algorithms, hash functions, and message authentication codes, plus a high level filter-based interface. The home page has a list of supported algorithms.
Botnet
BotNet is a library written in C, intended to assist in development of an IRC bot (or even an IRC client). It provides an easy-to-use model of communication with the IRC server by giving you string-sending functions and by returning messages from the IRC server into events to your application's main(). It also contains functions for easy DCC CHAT and SEND connections and an excess flood protection mechanism.
Bugs
BUGS is the Big and Useful Great Security key encryption algorithm and applications. It is easy to use, and includes sample applications and documentation. The cryptography library can also be used with your own programs. Features include:
  • Private key algorithm
  • Dynamic cryptography algorithm
  • Source code can be made public without making the algorithm weak
  • Infinite key lengths
  • Bilateral bits swwapping with various windows
  • Bilateral Pseudo randomly binary operations
  • Random number added to key
  • Random number generator using the ISAAC algorithm
  • Possibility of generating your own RNG seed
  • Five different cryptography levels, for the best possible
  • combination of efficiency and speed
  • Seed and shuffle functions
  • A clear text can be crypted using its own data
  • Two methods of execution: direct disk access or memory cache
  • Strong key generator
C++ Sockets
This is a GPL licensed C++ class library wrapping the Berkeley sockets C API. It treats one socket as one object. KThis is how the Socket class was born. This class, in itself, has all the functions needed for address translation (hostname to ip, ip to hostname etc). It owns the file descriptor / SOCKET handle. But it can't do anything. Code for actually doing something with the socket is implemented in other, Socket derived classes.
C-ares
'c-ares' is a C library that resolves names asynchronously. It is meant for applications that perform DNS queries without blocking or multiple DNS queries in parallel (ie servers that communicate with multiple clients and programs with GUIs).
C2hs
'c2hs' is an interface generator that simplifies the development of Haskell bindings to C libraries. It processes existing C header files that determine data layout and function signatures on the C side in conjunction with Haskell modules that specify Haskell-side type signatures and marshaling details. Hooks embedded in the Haskell code signal access to C structures and functions; they are expanded by the interfacing tool in dependence on information from the corresponding C header file.
C2lib
c2lib is a library of basic tools for use by C programmers. It contains features heavily influenced by both Perl's string handling and C++'s Standard Template Library (STL). Its goal is to provide some of the advantages of Perl with only around a factor of 2-3 code-size expansion, while retaining most of the efficiency advantages of C and remaining compatible with existing libc functions.
CDBlib
Read and write cdb ("constant database") files. Cdblib contains classes to read and write cdb ("constant database") files. Cdb files map string keys to string values with very fast record lookups. Cdblib also allows for in-memory indexes to enable even faster lookups.
CDimgtools
CDimg tools is a set of command line tools to manipulate CD/DVD images of certain formats.
CGAL
The goal of the CGAL Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods...
CGAL offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums) mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. All these data structures and algorithms operate on geometric objects like points and segments, and perform geometric tests on them. These objects and predicates are regrouped in CGAL Kernels.
CGKit (Python Computer Graphics Kit)
The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).
CHEAT
Minimal unit testing framework for the C programming language.
CImg
The CImg Library is a C++ toolkit that provides simple classes and functions for loading, saving, processing and displaying images in your own C++ code. It contains useful image processing algorithms for loading/saving, resizing/rotating, filtering, object drawing (text, lines, faces, ellipses,..), and more. Images are instancied by a class able to represent images up to 4-dimension wide (from 1-D scalar signals to 3-D volumes of vector-valued pixels), with template pixel types. The package compiles it with only the standard C libraries.
CLN
CLN is a C++ class library for numbers: integers, rational, float, complex, modular integer. It implements elementary, logical, transcendental functions. Unlimited precision, 100 million digits are no problem. Easy to use because of algebraic syntax and automatic memory management.
CMUSphinx- base
Sphinx is a speaker-independent large vocabulary continuous speech recognizer. It is also a collection of free and open source tools and resources that allows researchers and developers to build speech recognition systems. The packages that the CMU Sphinx Group is releasing are a set of reasonably mature, world-class speech components that provide a basic level of technology to anyone interested in creating speech-using applications without the once-prohibitive initial investment cost in research and development; the same components are open to peer review by all researchers in the field, and are used for linguistic research as well.
CUnit
CUnit is a light-weight library that allows programmers to test their C code. Test results can be browsed in multiple formats or built-in interfaces.
CWXML
CWXML is a C library for parsing and generating XML and BXML formats with a straightforward API. Initial testing indicates that it is 3 or more times faster than other popular libraries such as expat and libxml2 at parsing XML and much faster again with BXML (a free, patent-unencumbered binary-encoding format for XML data that is a replacement for an XML file that mirrors the XML markup structures in a way similar to the in-memory representations of many parser libraries).
Cadaver
'cadaver' is a command-line WebDAV client. It supports resource upload/download/display, namespace operations (copy/move), collection deletion/creation, property manipulation, and locking operations.
Cairo
Cairo is a 2D graphics library with support for multiple output devices. Currently supported output targets include the X Window System (via both Xlib and XCB), Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL, BeOS, OS/2, and DirectFB. Cairo is designed to produce consistent output on all output media while taking advantage of display hardware acceleration when available (eg. through the X Render Extension). The cairo API provides operations similar to the drawing operators of PostScript and PDF. Operations in cairo including stroking and filling cubic Bézier splines, transforming and compositing translucent images, and antialiased text rendering. All drawing operations can be transformed by any affine transformation (scale, rotation, shear, etc.) Cairo is implemented as a library written in the C programming language, but bindings are available for several different programming languages.


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.