Free Software Foundation!

Join now

Category/Mathematics

From Free Software Directory
Revision as of 07:40, 12 April 2011 by WikiSysop (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation,



Apophenia
'Apophenia' is a statistical library for C. It provides functions on the same level as those of the typical stats package (OLS, probit, singular value decomposition, &c.) but doesn't tie the user to an ad hoc language or environment. It uses the GNU Scientific Library for number crunching and SQLite for data management, so the library itself focuses on model estimation and quickly processing data.

Aris Heckert gnu.small.png
A sequential proof program, designed to assist anyone interested in solving logical proofs. Aris supports both propositional and predicate logic, as well as Boolean algebra and arithmetical logic in the form of abstract sequences. It uses a predefined set of both inference and equivalence rules, however gives the user options to use older proofs as lemmas, including Isabelle's Isar proofs.

Autoclass
AutoClass solves the problem of automatic discovery of classes in data (sometimes called clustering or unsupervised learning), as distinct from the generation of class descriptions from labeled examples (called supervised learning). It aims to discover the 'natural' classes in the data. AutoClass is applicable to observations of things that can be described by a set of attributes, without referring to other things. The data values corresponding to each attribute are limited to be either numbers or the elements of a fixed set of symbols. With numeric data, a measurement error must be provided.

Bc Heckert gnu.small.png
'Bc' is an arbitrary precision numeric processing language. Its syntax is similar to C, but differs in many substantial areas. It supports interactive execution of statements. 'Bc' is a utility included in the POSIX P1003.2/D11 draft standard. This version does not use the historical method of having bc be a compiler for the dc calculator (the POSIX document doesn't specify how bc must be implemented). This version has a single executable that both compiles the language and runs the resulting 'byte code.' The byte code is not the dc language.

Besssugo
besssugo is a free computational tool specifically designed to aid a cognizant expert—i.e. you, whether an engineer, scientist, technician, geek, etc—to build videos showing the result of a certain scientific calculation or whatever data can be computed or storied in a digital computer. Technically speaking, it is a plugin for the computational tool wasora, which provides means to parse and understand a high-level plain-text input file containing algebraic expressions, data for function interpolation, differential equations and output instructions amongst other facilities. Therefore, any mathematical computation which can be done by wasora—i.e. solving systems of differential-algebraic equations, multidimensional interpolation of scattered data, numerical integration and differentiation, etc.—can be combined with the facilities that besssugo provides to create visual representations in the form of animations.

C-Graph Heckert gnu.small.png
GNU C-Graph is a tool for visualizing the mathematical operation of convolution underlying natural phenomena susceptible to analysis in terms of engineering signals and systems theory. "C-Graph" is an abbreviation for "Convolution Graph". The package is derived from the BSc. Honours dissertation in Electrical Engineering "Interactive Computer Package Demonstrating: Sampling Convolution and the FFT", Adrienne Gaye Thompson, University of Aberdeen (1983). The package computes the linear convolution of two signals in the time domain then compares their circular convolution by demonstrating the convolution theorem. Each signal is modelled by a register of discrete values simulating samples of a signal, and the discrete Fourier transform (DFT) computed by means of the Fast Fourier Transform (FFT). GNU C-Graph is interactive, prompting the user to enter character or numerical values from the keyboard, dispensing with the learning curve for writing code. The software will be useful to students of signals and systems theory. C-Graph is written in contemporary Fortran. You can find pre-GNU development versions at: <http://codeartnow.com/code/download/c-graph-1/c-graph-version-2-preview>. Adrienne Gaye Thompson is the sole author of GNU C-Graph and looks forward to sharing further development with the FLOSS community.

Cl-ana
cl-ana is a library of modular utilities for reasonably high performance data analysis & visualization using Common Lisp. (Reasonably means I have to be able to use it for analyzing particle accelerator data). The library is made of various sublibraries and is designed in a very bottom-up way so that if you don't care about some feature you don't have to load it.

The functionality support so far are

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

Coq
A proof done with Coq is mechanically checked by the machine. In particular, Coq allows:

  • to define functions or predicates,
  • to state mathematical theorems and software specifications,
  • to develop interactively formal proofs of these theorems,
  • to check these proofs by a relatively small certification "kernel".

DUNE-Common
DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:

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

DUNE-Grid
DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). DUNE is free software licensed under the GPL (version 2) with a so called "runtime exception" (see license). This licence is similar to the one under which the libstdc++ libraries are distributed. Thus it is possible to use DUNE even in proprietary software. The underlying idea of DUNE is to create slim interfaces allowing an efficient use of legacy and/or new libraries. Modern C++ programming techniques enable very different implementations of the same concept (i.e. grids, solvers, ...) using a common interface at a very low overhead. Thus DUNE ensures efficiency in scientific computations and supports high-performance computing applications. DUNE is based on the following main principles:

  • 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.
… further results



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.


Personal tools
Namespaces

Variants
Actions
Navigation
Contribute