• an accurate version number within the shared library, allowing applications to select the appropriate data structures and functions to use at runtime, and
• a simplified interface with an unchanging ABI to the most common decoding functionality within FFmpeg.
• AVbin is distributed as a single dynamic library (.so on GNU/Linux, .dylib on Mac OS X, and .dll on Windows) that depends on no other files or installations. This eliminates the many complexities of building FFmpeg on platforms other than GNU/Linux; however you can still build it from source if you prefer.

Rationale

Casting complex objects from one type to another can be an uncomfortable process to express well. Objects that we use on a daily basis are not always in our control, and, even when they are, some don't lend themselves to simple construction. Remote service communication objects or complex data structures from libraries we use in our applications can result in large piles of casting code.

This circumstance often produces large swaths of procedural code, even if split up into separate function calls. This code can be not only difficult to understand, but difficult to test if an object requires a great deal of set up. Field or method assignments midway through can change and break the entire operation.

The goal of this project is to provide a method of defining easily digestible specifications for object translation that are also easily testable and changeable. The project focuses on writing specifications for transformations and not doing direct mutation in the recipes. The result is something that should seem somewhat functional, but also exceedingly separable.

Main Features

• The libraries use 63-bit addressing of array elements (all indexes and length are represented by 64-bit long type). So, it's theoretically possible to create and process arrays and matrices containing up to 2^63-1 (~10^19) elements of any primitive or non-primitive types, if OS and hardware can provide necessary amount of memory or disk space.

• Memory model concept allows storing AlgART arrays in different schemes, from simple Java arrays to mapped disk files; all necessary data transfers are performed automatically while every access to an element or a block of elements.

• Most of algorithms are based on wide usage of lazy evaluations. Typical operations, like elementwise summing or geometrical matrix transformations, are implemented via lazy views of the source array or matrix.

• • For example, you can take a multidimensional matrix, rotate it (or perform any other affine or projective transform), and then extract a submatrix from the result. All these operations will be performed virtually (not requiring time), and actual calculations will be performed only at the moment of accessing elements, usually while copying the resulting matrix to a newly created one. Moreover, in many cases the libraries will "understand" itself, that the user wants to perform rotation or another transform, and will split the matrix into suitable rectangular blocks (fitting in RAM) and choose the best algorithm for this task at the moment of copying operation.

• The libraries contain a wide set of image processing algorithms over matrices: linear filtering, mathematical morphology, rank operations, spectral transformation (FFT), etc.

• There is also skeletonization and measuring of binary images.

apel

• alist: utility for Association-list
• calist: utility for condition tree and condition/situation-alist
• filename: utility to make file-name
• install: utility to install emacs-lisp package
• mule-caeser: ROT 13-47-48 Caesar rotation utility
• path-util: utility for path management or file detection

emu

• broken: provide information of broken facilities of Emacs.
• invisible: provide features about invisible region
• mcharset: provide MIME charset related features
• pces: provide portable character encoding scheme features
• pccl: utility to write portable CCL program
• pcustom: provide portable custom environment
• poe: emulation module for basic functions and special forms/macros
• poem: provide basic functions to write portable MULE programs
• static: utility for static evaluation

Note

• enthought.appscripting: Framework for scripting applications.
• enthought.help: Provides a plugin for displaying documents and examples and running demos in Envisage Workbench applications.
• enthought.io: Provides an abstraction for files and folders in a file system.
• enthought.naming: Manages naming contexts, supporting non-string data types and scoped preferences.
• enthought.permissions: Supports limiting access to parts of an application unless the user is appropriately authorised (not full-blown security).
• enthought.persistence: Supports pickling the state of a Python object to a dictionary, which can then be flexibly applied in restoring the state of the object.
• enthought.preferences: Manages application preferences.
• enthought.resource: Manages application resources such as images and sounds.
• enthought.scripting: A framework for automatic recording of Python scripts.
• enthought.sweet_pickle: Handles class-level versioning, to support loading of saved data that exist over several generations of internal class structures.
• enthought.template: Supports creating templatizable object hierarchies.
• enthought.type_manager: Manages type extensions, including factories to generate adapters, and hooks for methods and functions.
• enthought.undo: Supports undoing and scripting application commands.

• AutoOpts - automates the handling of command line, environment and config file options, including usage text, man pages, and the invoking section of an info doc
• getdefs - extracts AutoGen definitions from stylized comments embedded in source code
• columns - tabularizes lists for improved output appearance
• AutoXDR - NFSv4 specifies that its remote procedure calls be batched. AutoGen generates the code for marshalling and unmarshalling the arguments on both sides of the RPC request
• AutoFSM - produces a transition table and prototype finite state machine where it is possible to determine a state transition type (token code) without reference to the current state
• xml2ag - lets AutoGen use any XML file as if it were a set of AutoGen definitions

• 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.

• 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)

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

• 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

• Promote the rapid development of OpenCL host programs in C (with support for C++) and avoid the tedious and error-prone boilerplate code usually required.
• Assist in the benchmarking of OpenCL events, such as kernel execution and data transfers. Profiling comes for free with cf4ocl.
• Simplify the analysis of the OpenCL environment and of kernel requirements.
• Allow for all levels of integration with existing OpenCL code: use as much or as few of cf4ocl required for your project, with full access to the underlying OpenCL objects and functions at all times.

• Object-oriented interface to the OpenCL API

• OpenCL version and platform independent
• Integrated profiling
• Advanced device query utility
• Offline kernel compiler and linker

• Parses GET and POST form data transparently.
• Provides string, integer, floating-point and single- and multiple-choice retrieval methods for form data.
• Provides methods for saving and restoring CGI environments to aid in application debugging.
• Provides full on-the-fly web-authoring generation capabilities, with support for cookies.
• Supports web-authoring file upload.

• Designed for 2D video games.
• Circle, convex polygon, and line segment collision primitives.
• Multiple collision primitives can be attached to the same rigid body.
• Fast collision detection by using a spatial hash for the broad phase.
• Extremely fast impulse solving by utilizing Erin Catto's contact persistence algorithm.
• Support for collision callbacks based on object types.
• Impulses applied to contact points can be retrieved after the impulse solver has finished.
• Several kinds of joints available.
• C99 implementation, no external dependencies.
• Ruby extension available.
• Simple, read the documentation.

• No dependencies
• Cross-Platform
• No Server Required
• No Install Needed
• Network-Based

• Tabular data analysis: Read-write of large datasets stored in HDF5 files are supported, along with ntuple datasets, CSVs, and in-memory data tables. Users can add their own table types by defining 4 methods and extending the table CLOS type.

• Histograms: Binned data analysis is supported with both contiguous and sparse histogram types; functional interface is provided via map (which allows reduce/fold) and filter.

• Plotting: Uses gnuplot for plotting dataset samples, plain-old lisp functions, histograms, strings-as-formulae, and anything else the user wishes to add via methods on a couple of generics.

• Fitting: Uses GSL for non-linear least squares fitting. Uses plain-old lisp functions as the fit functions and can fit against dataset samples, histograms, and whatever the user adds.

• Generic mathematics: CL doesn't provide extendable math functions, so cl-ana provides these as well as a convenient mechanism (a single function) for using these functions instead of the non-extendable versions. Already included are error propogation and quantities (values with units, e.g. 5 meters) as well as a GNU Octave-style handling of sequences (e.g. (+ (1 2) (3 4)) --> (4 6)).

• Generating C/C++ source code.
• Compiling this source code and dynamically loading it into the Python interpreter.
• Both capabilities are meant to be used together, but also work on their own. In particular, the code generation facilities work well in conjunction with PyCuda. Dynamic compilation and linking are so far only supported in GNU/Linux with the GNU toolchain.

• BSD sockets (IPv4, IPv6, TCP, UDP)
• OpenSSL secure streams
• NSPR sockets
• NSS secure streams
• Kernel message queues
• Files and pipes
• Serial/tty
• Gtkmm widgets
• et. al.

• couchdb.client: the basic client library
• couchdb.design: management of design documents
• couchdb.schema: a higher-lever API for mapping between CouchDB documents and Python objects
• couchdb.view: a CouchDB view server that allows writing view functions in Python

llibcurl

• Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
• Efficient implementation of these interfaces using generic programming techniques.
• Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
• Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
• The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
• dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
• dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
• dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

• Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
• Efficient implementation of these interfaces using generic programming techniques.
• Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
• Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
• The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
• dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
• dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
• dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

• Separation of data structures and algorithms by abstract interfaces.- This provides more functionality with less code and also ensures maintainability and extendability of the framework.
• Efficient implementation of these interfaces using generic programming techniques.
• Static polymorphism allows the compiler to do more optimizations, in particular function inlining, which in turn allows the interface to have very small functions (implemented by one or few machine instructions) without a severe performance penalty. In essence the algorithms are parametrized with a particular data structure and the interface is removed at compile time. Thus the resulting code is as efficient as if it would have been written for the special case.
• Reuse of existing finite element packages with a large body of functionality.- In particular the finite element codes UG, ALBERTA, and ALUGrid have been adapted to the DUNE framework. Thus, parallel and adaptive meshes with multiple element types and refinement rules are available. All these packages can be linked together in one executable.
• The framework consists of a number of modules which are downloadable as separate packages. The current core modules are:
• dune-common- contains the basic classes used by all DUNE-modules. It provides some infrastructural classes for debugging and exception handling as well as a library to handle dense matrices and vectors.
• dune-grid- is the most mature module. It defines nonconforming, hierarchically nested, multi-element-type, parallel grids in arbitrary space dimensions. Graphical output with several packages is available, e.g. file output to IBM data explorer and VTK (parallel XML format for unstructured grids). The graphics package Grape has been integrated in interactive mode.
• dune-istl (Iterative Solver Template Library)- provides generic sparse matrix/vector classes and a variety of solvers based on these classes. A special feature is the use of templates to exploit the recursive block structure of finite element matrices at compile time. Available solvers include Krylov methods, (block-) incomplete decompositions and aggregation-based algebraic multigrid.

• Support for http, https, ftp, nntp and news URL schemes.
• htdb virtual URL scheme support for indexing SQL databases.
• text/html, text/xml, text/plain, audio/mpeg (MP3) and image/gif mime types built-in support.
• External parsers support for other document types.
• Ability to index multilangual sites using content negotiagion.
• Searching all of the word forms using ispell affixes and dictionaries.
• Stopwords and synonyms lists.
• Boolean query language support.
• Results sorting by relevancy, popularity rank, last modified time and by importance (a multiplication of relevancy and popularity rank).
• Various character sets support.
• Accent insensitive search.
• Phrases segmenting for Chinese, Japanese, Korean, and Thai.
• mod_dpsearch - search module for Apache web server.
• Internationalized Domain Names support

• hamiltonian monte carlo sampling (HMC) and simple bayesian neural network
• second order L-BFGS search
• gradient descent (backpropagation)

Main features

• Embeddable, portable, compact: can run on platforms with 160kB flash and 64kB RAM
• ECMAScript E5/E5.1, with some semantics updated from ES2015+
• Partial support for ECMAScript 2015 (E6) and ECMAScript 2016 (E7), see Post-ES5 feature status and kangax/compat-table
• ES2015 TypedArray and Node.js Buffer bindings
• CBOR bindings
• Encoding API bindings based on the WHATWG Encoding Living Standard
• performance.now()
• Built-in debugger
• Built-in regular expression engine
• Built-in Unicode support
• Minimal, retargetable platform dependencies
• Combined reference counting and mark-and-sweep garbage collection with finalization
• Coroutines
• Property virtualization using a subset of ECMAScript ES2015 Proxy object
• Bytecode dump/load for caching compiled functions
• Distributable includes an optional logging framework, CommonJS-based module loading implementations, etc
• Liberal license (MIT)

• Tuples and tables (relvars).
• Relational algebra: RENAME, select (restrict), project, EXTEND, JOIN, SEMIJOIN, UNION, INTERSECT, MINUS, SEMIMINUS, SUMMARIZE PER, DIVIDEBY PER, WRAP, UNWRAP, GROUP, and UNGROUP.
• Virtual tables (views).
• Locking and nested transactions.
• Duro tables are true sets -- uniqueness of tuples (rows) is always enforced. When creating real tables, at least one candidate key must be supplied. A candidate key may be empty.
• User-defined types (including type constraints) and operators.
• Declarative integrity.
• Tcl interface, including support for relational expressions in Tutorial D syntax and operators implemented in Tcl ("stored procedures").
• Simple GUI admin tool.

• A program working with sound can install additional effect filters while running.
• A file manager can add plugins that handles new archive types.
• Or it can add file popup menu handlers, or toolbar commands from plugins.
• A text editor can add an editing mode (say Python editing) when the text editor is running.
• So, plugins can make a static application a lot more dynamic. And DynObj does this in a generic, type safe way.

• Elib has been decommissioned as a separate package since its useful functions have long since been included in Emacs.

• etsconfig: Supports configuring settings that need to be shared across multiple projects or programs on the same system. Most significant of these is the GUI toolkit to be used. You can also configure locations for writing application data and user data, and the name of the company responsible for the software (which is used in the application and user data paths on some systems).
• logger: Provides convenience functions for creating logging handlers.
• util: Provides miscellaneous utility functions.