Semantic search

Jump to: navigation, search


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.
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.
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.
C-graph Heckert gnu.tiny.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: Code Art Now. Adrienne Gaye Thompson is the sole author of GNU C-Graph and looks forward to sharing further development with the Free software community.
C3.js
Enables deeper integration of charts into web applications.
Calc
"Calc" is an advanced calculator and mathematical tool that runs as part of the GNU Emacs environment. Very roughly based on the HP-28/48 series of calculators, its many features include: * Choice of algebraic or RPN (stack-based) entry of calculations. * Arbitrary precision integers and floating-point numbers. * Arithmetic on rational numbers, complex numbers (rectangular and polar), error forms with standard deviations, open and closed intervals, vectors and matrices, dates and times, infinities, sets, quantities with units, and algebraic formulas. * Mathematical operations such as logarithms and trigonometric functions. * Programmer's features (bitwise operations, non-decimal numbers). * Financial functions such as future value and internal rate of return. * Number theoretical features such as prime factorization and arithmetic modulo M for any M. * Algebraic manipulation features, including symbolic calculus. * Moving data to and from regular editing buffers. * "Embedded mode" for manipulating Calc formulas and data directly inside any editing buffer. * Graphics using gnuplot, a versatile plotting program. * Easy programming using keyboard macros, algebraic formulas, algebraic rewrite rules, or extended Emacs Lisp.
Choose
Choose is a program that computes permutations and choose functions. It does so quickly and effectively. Choose falls into the category of programs that are simple but are useful and for some reason do not exist.
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)).
Collab
Multiplatform raster graphical editor enabling simultaneous drawing between users. Project including several sub projects as server, painting framework, network library, desktop application and protocol design and documentation.
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".
CrocoPat
'CrocoPat' is a tool for querying and manipulating relations. It is easy to use because of its simple query and manipulation language based on predicate calculus and its simple file format for relations. It is efficient because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations. CrocoPat is general, because it manipulates not only graphs (i.e. binary relations), but n-ary relations.
Ctioga2
ctioga2 is a plotting program in the spirit of gnuplot. It can be used either directly on command-line or writing command files (or a mix of both). It produces publication-quality PDF files. It is based on the Tioga plotting library.
Cuba
The Cuba library offers a choice of four independent routines for multidimensional numerical integration: Vegas, Suave, Divonne, and Cuhre. They work by very different methods, first three are Monte Carlo based. All four have a C/C++, Fortran interface and can integrate vector integrands. Their invocation is very similar, so it is easy to substitute one method by another for cross-checking. For further safeguarding, the output is supplemented by a chi-square probability which quantifies the reliability of the error estimate.
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.
DUNE-Grid How To
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-ISTL
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.
Dap Heckert gnu.tiny.png
Dap is a small statistics and graphics package, based on C, that provides core methods of data management, analysis, and graphics commonly used in statistical consulting practice. Anyone familiar with basic C syntax can learn Dap quickly and easily from the manual and the examples in it. Advanced features of C are not necessary, although they are available. As of Version 3.0, Dap can read SBS programs, thereby freeing the user from having to learn any C at all to run straightforward analyses. The manual contains a brief introduction to the C syntax needed for C-style programming for Dap. Because Dap processes files one line at a time, rather than reading entire files into memory, it can be, and has been, used on data sets that have very many lines and/or very many variables.
Data Frame
In the R language, a dataframe object is a way to group tabular data. The functions in this package allow the manipulation of data in a similar way in Octave. Dataframe objects in Octave can be created in a variety of ways (from other objects or from tabular data in a file) and then can be accessed either as matrix or by column name. This Octave add-on package is part of the Octave-Forge project.
DataCaptureTool
This is a candidate for deletion: All links broken. Software not on archive.org. Email to maintainer broken. poppy-one (talk) 02:37, 28 July 2018 (EDT) DataCapture was born out of frustration, and after much procrastination. Every time I had to get numerical values of a graph from a journal or a conference paper, I had to painstakingly approximate data points from the graph as best I could. Every time the points would come out inaccurate and a rather poor reproduction of the actual data. I wanted to write a program that would automate this task, and do a much better job at that. But then, that was three years ago. Finally its done. Its not the best thing that I have created, but certainly, one of the most useful. Its written in TCl/Tk and is a very small and uncomplicated aplication. Something that you can easily incorporate into your own applications easily.
DataMelt
DataMelt (DMelt) is an environment for numeric computation, statistical analysis, data mining, and graphical data visualization on the Java platform. This Java multiplatform program is integrated with a number of scripting languages: Jython (Python), Groovy, JRuby, BeanShell. DMelt can be used to plot functions and data in 2D and 3D, perform statistical tests, data mining, numeric computations, function minimization, linear algebra, solving systems of linear and differential equations. Linear, non-linear and symbolic regression are also available. Neural networks and various data-manipulation methods are integrated using powerful Java API. Elements of symbolic computations using Octave/Matlab scripting are supported.
DataStatix
DataStatix is a free software for GNU/Linux and Windows useful to manage data of every kind (although it has been written to manage biomedical data), to create descriptive statistics and graphs and to export items easily to R environment or to other statistic softwares. In order to handle properly big amount of data and many concurrent users, DataStatix works with MySql database and it has been developed and tested with MySql community edition 5.5. Some features of the software are: users management (create, delete, modify password) within the software; different users levels of data access (administrator, default, read only); user defined templates (models) of data, to create new databases easily; importation and esportation of data in CSV format (used also by Calc and Excel); updating of existing data from a CSV file created with DataStatix; descriptive statistics from every data (some more kind of statistics to come); graphs from every data.
Datamash Heckert gnu.tiny.png
Datamash is a command-line program which performs basic numeric, textual and statistical operations on input textual data files. Datamash is designed to be portable and reliable, and aid researchers to easily automate analysis pipelines, without writing code or even short scripts.
Dezyne
The Dezyne language has formal semantics expressed in mCRL2 developed at the department of Mathematics and Computer Science of the Eindhoven University of Technology (TUE). Dezyne requires that every model is finite, deterministic and free of deadlocks, livelocks, and contract violations. This achieved by means of the language itself as well as by builtin verification through model checking. This allows the construction of complex systems by assembling independently verified components.
Dinrhiw2
Primary aim of the dinrhiw is to be linear algebra library and machine learning library. For this reason dinrhiw implements PCA and neural network codes. Currently, the neural network code only supports:
  • hamiltonian monte carlo sampling (HMC) and simple bayesian neural network
  • second order L-BFGS search
  • gradient descent (backpropagation)
As well as mathematical routines for arbitrary precision mathematics, hermite curve interpolation and many other things.
Dr-geo Heckert gnu.tiny.png
Dr. Geo, design & manipulate interactive geometric sketches with constraints. Dr. Geo aim is to be an open, easy to study, modify and extend interactive geometry software. It is distributed with its source code you can modify while using it. Ten years old kids use Dr. Geo to explore Euclidean geometric sketch, agile kids extend and program it with its embedded dynamic Smalltalk language and user interface.
Easyval
'Easyval' is a basic implementation of interval arithmetic that uses hardware doubles as interval bounds. The first goal of this library is to respect the interval arithmetic containment criterium.
Emgr
Empirical gramians can be computed for linear and nonlinear control systems for purposes of model order reduction, uncertainty quantification or system identification. Model reduction using empirical gramians can be applied to the state space, the parameter space of dynamical systems and control systems. The emgr framework is a compact open source toolbox for (empirical) gramian-based model reduction and compatible with OCTAVE and MATLAB.
Euler
This the GTK port of Euler, a program for quicky and interactvely computing with real and complex numbers and matrices. It features advanced graphical capabilities and a simple programming language. It is often used for tasks such as inspecting and discussing functions of one real or complex variable, viewing surfaces in parameter representation, linear algebra and eigenvalue computation, testing numerical algorithms, solving differential equations numerically, computing polynomials, studying interval arithmetic, or examining and generating sound files.
FractGen
FractGen is a simple Qt-based fractal generator program for Mandelbrot fractals. The image size is only limited by virtual memory. It is possible to zoom into images. Image parameters can be saved in XML files and loaded from XML files. Calculated images can be exported as PNG files. The intention of this program is to generate graphics to be post-processed by other image tools, e.g. in order to generate nice screen backgrounds or book covers.
FroZenLight
FroZenLight connects simple line art and mathematics. The source of light can be positioned so that either symmetric reflection patterns or secret messages (Cryptography) are created. Dozens of example light patterns and some math exercises are provided.
FunkyPlot
FunkyPlot is an interactive plotting tool for mathematical functions, designed for pupils and students.
GAP
Warning: this entry need a more profound looking into all directories and sub-directories the project is very big it could take some time. GAP is a system for computational discrete algebra, with particular emphasis on Computat ional Group Theory. GAP provides a programming language, a library of thousands of functions implementing algebraic algorithms written in the GAP language as well as large data libraries of algebraic objects. GAP is used in research and teaching for studying groups and their representations, rings, vector spaces, algebras, combinatorial structures, and more. The system, including source, is distributed freely. You can study and easily modify or extend it for your special use.
GNU SETL
GNU SETL is a modest extension and implementation of SETL, the World's Most Wonderful Programming Language.
GNumExp
'gNumExp' is a GUI frontend to NumExp, a math-oriented programming language. It provides a graphic console with integrated help system, and a powerful function plotter.
GTybalt
gTybalt is an object-oriented program that allows symbolic calculations within C++. Solutions developed with gTybalt can be compiled with a C++ compiler and executed independently of gTybalt; this is particular important for computer-extensive problems. 'gTybalt' can interpret C++ and execute C++ scripts. Solutions can be developed quickly for small-scale problems, either interactively or through scripts, and once debugged, the solutions can be compiled and scaled up to large-scale problems. Mathematical formulae are visualized using TeX fonts and converted to LaTeX on a WYSIWYG basis.
Genius
'Genius' is an arbitrary precision integer and multiple precision floating point calculator. It can deal with rational numbers and complex numbers. It has matrix support as well. It uses the gmp library so it is very fast for calculations of large numbers. It has a command line and a GNOME interface.
GiNaC
GiNaC is an acronym for GiNaC Is Not A CAS, where CAS stands for Computer Algebra System. It lets the user create integrated systems that embed symbolic manipulations together with more established areas of computers sciences under one roof. It has been specifically developed to become a replacement engine for xloops. However, it is not restricted to high energy physics applications. Its design is revolutionary in that contrary to other CAS it does not try to provide extensive algebraic capabilities and a simple programming language but instead accepts a given language (C++) and extends it by a set of algebraic capabilities.
Giac
Giac/Xcas is a free computer algebra system. It has a compatibility mode for maple, mupad and the TI89. It is available as a standalone program (graphic or text interfaces) or as a C++ library.
Glpk
GLPK is a C library for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It supports the GNU MathProg modeling language, a subset of the AMPL language, and features a translator for the language. In addition to the C library, a stand-alone LP/MIP solver is included in the package. This is a GNU package.
Gmp Heckert gnu.tiny.png
GMP is a library for arbitrary precision arithmetic, operating on signed integers, rational numbers and floating point numbers. The precision is only limited by the available memory. The library is highly optimized, with a design focus on execution speed. It is aimed at use in, for example, cryptography and computational algebra.
Gnuplot
Gnuplot is a portable command-line driven graphing utility. It was originally created to allow scientists and students to visualize mathematical functions and data interactively, but has grown to support many non-interactive uses such as web scripting. It is also used as a plotting engine by third-party applications like GNU Octave. Gnuplot has been supported and under active development since 1986.
Gravit Sandbox
Gravit is a gravity sandbox made with python and pygame. It is composed of a launcher and a simulator.
Gretl Heckert gnu.tiny.png
Gretl, an acronym for Gnu Regression Econometrics and Time-series Library, is a package for performing statistical computations for econometrics. It consists of both a command-line client and a graphical client. It features a variety of estimators such as least-squares and maximum likelihood; several time series methods such as ARIMA and GARCH; limited dependent variables such as logit, probit and tobit; and a powerful scripting language. It can output models as LaTeX files. It also may be linked to GNU R and GNU Octave for further data analysis.
Gsegrafix Heckert gnu.tiny.png
GSEGrafix is an application which produces high-quality graphical plots for science and engineering. Plots are specified via simple ASCII parameter files and data files and are presented in an anti-aliased GNOME canvas. The program supports rectangular two-dimensional plots, histograms, polar-axis plots and three-dimensional plots. Plots can be printed or saved to BMP, JPEG or PNG image formats. GSEGrafix can also be run both from a command prompt and from Octave.
Gsl Heckert gnu.tiny.png
The GNU Scientific Library is a library for numerical analysis in C and C++. It includes a wide range of mathematical routines, with over 1000 functions in total. Subject areas covered by the library include: differential equations, linear algebra, Fast Fourier Transforms and random numbers.
Guile-cv Heckert gnu.tiny.png,

Guile-CV
Image Processing and Analysis in Guile
a Computer Vision functional programming library
Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API.
Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.
INFOTOPO
Programs for Information Topology Data Analysis Information Topology is a program written in Python (compatible with Python 3.4.x), with a graphic interface built using TKinter [1], plots drawn using Matplotlib [2], calculations made using NumPy [3], and scaffold representations drawn using NetworkX [4]. It computes all the results on information presented in the study [5], that is all the usual information functions: entropy, joint entropy between k random variables (Hk), mutual informations between k random variables (Ik), conditional entropies and mutual informations and provides their cohomological (and homotopy) visualisation in the form of information landscapes and information paths together with an approximation of the minimum information energy complex [5]. It is applicable on any set of empirical data that is data with several trials-repetitions-essays (parameter m), and also allows to compute the undersampling regime, the degree k above which the sample size m is to small to provide good estimations of the information functions [5]. The computational exploration is restricted to the simplicial sublattice of random variable (all the subsets of k=n random variables) and has hence a complexity in O(2^n). In this simplicial setting we can exhaustively estimate information functions on the simplicial information structure, that is joint-entropy Hk and mutual-informations Ik at all degrees k=<n and for every k-tuple, with a standard commercial personal computer (a laptop with processor Intel Core i7-4910MQ CPU @ 2.90GHz * 8) up to k=n=21 in reasonable time (about 3 hours). Using the expression of joint-entropy and the probability obtained using equation and marginalization [5], it is possible to compute the joint-entropy and marginal entropy of all the variables. The alternated expression of n-mutual information given by equation then allows a direct evaluation of all of these quantities. The definitions, formulas and theorems are sufficient to obtain the algorithm [5]. We will further develop a refined interface (help welcome) but for the moment it works like this, and requires minimum Python use knowledge. Please contact pierre.baudot [at] gmail.com for questions, request, developments (etc.): [1] J.W. Shipman. Tkinter reference: a gui for python. . New Mexico Tech Computer Center, Socorro, New Mexico, 2010. [2] J.D. Hunter. Matplotlib: a 2d graphics environment. Comput. Sci. Eng., 9:22–30, 2007. [3] S. Van Der Walt, C. Colbert, and G. Varoquaux. The numpy array: a structure for efficient numerical computation. Comput. Sci. Eng., 13:22– 30, 2011. [4] A.A. Hagberg, D.A. Schult, and P.J. Swart. Exploring network structure, dynamics, and function using networkx. Proceedings of the 7th Python in Science Conference (SciPy2008). Gel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pages 11–15, 2008. [5] M. Tapia, P. Baudot, M. Dufour, C. Formisano-Tréziny, S. Temporal, M. Lasserre, J. Gabert, K. Kobayashi, JM. Goaillard . Information topology of gene expression profile in dopaminergic neurons doi: https://doi.org/10.1101/168740 http://www.biorxiv.org/content/early/2017/07/26/168740
IT++
IT++ is a C++ library of mathematical, signal processing, speech processing, and communications classes and functions. It is being developed by researchers in these areas and is widely used by researchers, both in the communications industry and universities. Since 2004, IT++ is also being developed as a part of the European Network of Excellence in Wireless Communications (NEWCOM). The kernel of the IT++ library are templated vector and matrix classes, and lots of functions for vectors and matrices. Such a kernel makes IT++ library similar to Matlab. IT++ makes an extensive use of existing free software libraries (but not only) for increased functionality, speed and accuracy. In particular BLAS, CBLAS, LAPACK and FFTW libraries might be used. Instead of NetLib's reference BLAS and LAPACK, some optimized platform-specific libraries can be used as well, i.e.:
  • ATLAS (Automatically Tuned Linear Algebra Software) - includes optimised BLAS, CBLAS and a limited set of LAPACK routines
  • MKL (Intel Math Kernel Library) - includes all required BLAS, CBLAS, LAPACK and FFT routines (FFTW not required)
  • ACML (AMD Core Math Library) - includes BLAS, LAPACK and FFT routines (FFTW not required)
It is possible to compile and use IT++ without any of the above listed libraries, but the functionality will be reduced. The IT++ library originates from the former department of Information Theory at the Chalmers University of Technology, Gothenburg, Sweden. Because the library is coded in C++, the name IT++ seemed like a good idea at the time. While departments come and go, IT++ have developed a life of its' own and is now released under the terms of the GNU General Public License (GPL) for you to enjoy. IT++ should work on GNU/Linux, Sun Solaris, Microsoft Windows (with Cygwin, MinGW/MSYS, or Microsoft Visual C++ .NET) and Mac OS X operating systems.
Interval RPN Calculator
This terminal app runs on PCs or laptops running Windows, OSX or GNU/Linux. It attempts to mimic the functionality of an HP ReversePolishNotation [RPN] calculator with the added enhancement of interval output. So along with your answer, you get a good idea of its trustworthiness.


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.