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.
Isabelle
Isabelle is a generic proof assistant. It allows mathematical formulas to be expressed in a formal language and provides tools for proving those formulas in a logical calculus. The main application is the formalization of mathematical proofs and in particular formal verification, which includes proving the correctness of computer hardware or software and proving properties of computer languages and protocols.
Jacal Heckert gnu.tiny.png
JACAL is an interactive symbolic math program that can manipulate and simplify equations, scalars, vectors, and matrices of single and multiple valued algebraic expressions containing numbers, variables, radicals, and algebraic differential, and holonomic functions.
Jackrabbit Relay
Jackrabbit Relay is a framework to manage trading signal alerts in JSON format from TradingView or similiar software to place trades on an exchange or broker.
KNIME
KNIME [naim] is a user-friendly graphical workbench for the entire analysis process: data access, data transformation, initial investigation, powerful predictive analytics, visualisation and reporting. The open integration platform provides over 1000 modules (nodes), including those of the KNIME community and its extensive partner network.
KSEG
KSEG is a GNU/Linux program for exploring Euclidean geometry. You create a construction, such as a triangle with a circumcenter, and as you drag verteces of the triangle, the circumcenter moves in real time. Other features include:
  • Fast core which supports large constructions
  • Supports multiple languages
  • Construction of points, segments, rays, lines, circles, and arcs
  • Make measurements
  • Transformations (rotation, translation, scaling, reflection)
  • Construction of adaptively sampled loci for better quality and speed
  • Reverse dragging
  • Infinite undo/redo
  • Ability to easily redefine points to "edit" drawings
  • Editable scripting/macro with support for recursion
  • Pretty formulas for calculations-with libkformula
  • Small files
  • Quick play--one step to play any construction from a directory
  • Calculation based transformations
  • Improved selection-to-given matching in constructions
Kiss FFT
Kiss FFT is a small and simple FFT library. It has no complicated platform-specific optimizations, can do either fixed or floating point with just a recompile, and is efficient enough for all but the most demanding applications.
Kmplot
kmplot is a mathematical function plotter for the KDE desktop. A powerful parser is included. You can plot different functions simultaneously and combine their function terms to build new functions. kmplot supports functions with parameters and functions in polar coordinates. Several grid modes are possible. Plots may be printed with high precision in correct scale.
Kpl
Kpl is a program for two- and three-dimensional graphical presentation of data sets and functions. It performs multidimensional nonlinear parameter fits of functions to data sets using the Levenberg-Marquardt algorithm; general linear least square parameter fits are also possible. Other applications and scripts can control Kpl through a D-BUS interface. All presentation settings may be saved in plot files. Both plot and data files may be chosen by command line parameters, through the File menu, or by drag and drop. The program supports automatic scaling and normalization as well as automatic parameter fits. Presentation settings can be changed using the Edit menu. Additional data sets and functions can be displayed in the either the same or a different data window.
L2P
'L2P' creates PNG images from LaTeX math expressions. It can work with either a fragment of LaTeX code (such as $\frac{x^2+1}{3-x}$) or with a full LaTeX document. It is designed to be fast, robust, and to offer the user a high degree of flexibility and control. It includes complete documentation.
LAPACK
LAPACK is written in Fortran77 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.
Lcn2-calc
calc is an arbitrary precision arithmetic system that uses a C-like language. It's useful as a calculator, an algorithm prototype, and as a mathematical research tool. More importantly, calc provides a machine-independent means of computation. Its features include:
  • Arbitrary precision integers and floating-point, fractions and complex values
  • Logarithm, numeric, trig, hyperbolic functions
  • C-like syntax
  • calc shell scripts, resource files, linkable program library
  • User defined finctions and function loading
  • Over 283 built-in functions plus hooks for built-in custom extensions
  • Arrays, lists, dynamic strings, matrices, associate arrays, objects
  • Numeric, relational, boolean and variable access operators
  • Extensive string and binary block memory builtin functions
  • Matrix inversion, determinant, and other matrix operations
  • Fast and cryptographic pseudo-random numbers, cryptographic hashes
  • Factoring, primality tests, pi(x), multiplicative inverse, modular exp
  • Bernoulli numbers, Euler numbers, Catalan numbers
  • Uses REDC, splint-point and other high speed multi-precision algorithms
  • Extensive regression test suite
  • Resource functions: large prime tests, factoring, quaternions, etc.
  • File I/O, multi-precision printf and scanf, stdio-like functions
  • GNU Readline, user & system startup scripts, Emacs-style line editing
  • Online help
Libmatheval Heckert gnu.tiny.png
GNU libmatheval is a library that makes it possible to calculate mathematical expressions for given variable values and to calculate expression's derivative with respect to a given variable. The library supports arbitrary variable names in expressions, decimal constants, basic unary and binary operators and elementary mathematical functions. The library is stable and available for general use.
LibreOffice
LibreOffice is a comprehensive office suite. It contains a number of components: Writer, a word processor; Calc, a spreadsheet application; Impress, a presentation engine; Draw, a drawing and flowcharting application; Base, a database and database frontend; Math for editing mathematics. There are also a good and growing number of free software extensions and templates available. LibreOffice is a fork of OpenOffice.org, which is now called Apache OpenOffice. Because Apache OpenOffice hosts and recommends using proprietary extensions, we do not recommend using it.
Librsb
librsb is a library for sparse matrix computations featuring the Recursive Sparse Blocks (RSB) matrix format. This format allows cache efficient and multi-threaded (that is, shared memory parallel) operations on large sparse matrices. The most common operations necessary to iterative solvers are available, e.g.: matrix-vector multiplication, triangular solution, rows/columns scaling, diagonal extraction / setting, blocks extraction, norm computation, formats conversion. The RSB format is especially well suited for symmetric and transposed multiplication variants. On these variants, librsb has been found to be faster than Intel MKL's implementation for CSR. Most numerical kernels code is auto generated, and the supported numerical types can be chosen by the user at build time. librsb implements the Sparse BLAS standard, as specified in the BLAS Forum documents.
MCS Libre (Monte-Carlo simulation)
MCS-libre is a free utility for Monte-Carlo simulation. It is a library of header files that can easily be inserted into a C++ program. A C++ compiler is required. This author recommends using the GNU compiler g++.
MLPACK
MLPACK is a C++ machine learning library with emphasis on scalability, speed, and ease-of-use. Its aim is to make machine learning possible for novice users by means of a simple, consistent API, while simultaneously exploiting C++ language features to provide maximum performance and flexibility for expert users. MLPACK contains the following algorithms: Collaborative Filtering, Density Estimation Trees, Euclidean Minimum Spanning Trees, Fast Exact Max-Kernel Search (FastMKS), Gaussian Mixture Models (GMMs), Hidden Markov Models (HMMs), Kernel Principal Component Analysis (KPCA), K-Means Clustering, Least-Angle Regression (LARS/LASSO), Local Coordinate Coding, Locality-Sensitive Hashing (LSH), Logistic regression, Naive Bayes Classifier, Neighbourhood Components Analysis (NCA), Non-negative Matrix Factorization (NMF), Principal Components Analysis (PCA), Independent component analysis (ICA), Rank-Approximate Nearest Neighbor (RANN), Simple Least-Squares Linear Regression (and Ridge Regression), Sparse Coding, Tree-based Neighbor Search (all-k-nearest-neighbors, all-k-furthest-neighbors), Tree-based Range Search.
MPK
MathParseKit is a C++ Library that allows an easy integration of a mathematical functions interpreter.
MUNTL
'MUNTL' is a multiprecision unsigned number template library. It is intended for the organization of calculations with the big precision for unsigned numbers, ie cases where there are unsigned numbers whose length exceeds the ability of a current platform to handle them. These cases include storage of big numbers (ie factorials) and the operations associated with them, emulation of registers of large length, and indications of errors in position code.
Macaulay 2
Macaulay 2 is a software system devoted to supporting research in algebraic geometry and commutative algebra. is available now in source code for porting, and in compiled form for GNU/Linux, SunOS, Solaris, and a few other unix machines.
Mandelbulber
Mandelbulber is an experimental application that helps to make rendering 3D Mandelbrot fractals much more accessible. A few of the supported 3D fractals: Mandelbulb, Mandelbox, BulbBox, JuliaBulb, Menger Sponge, Quaternion, Trigonometric, Hypercomplex, and Iterated Function Systems. All of these can be combined into infinite variations with the ability to hybridize different formulas together.
Mantissa
'Mantissa' is a collection of various mathematical algorithms in Java aimed towards simulation. It features a small set of linear algebra classes, a least squares estimator, some curve fitting classes, several ordinary differential equation integrators (all supporting multiple switching functions and dense output), vectors and rotations in a three dimensional space, algebra-related classes like rational and double polynomials, various orthogonal polynomials, some optimization algorithms using direct search methods, and more.
Mastrave
Mastrave is a free software library written to perform vectorized scientific computing and to be as compatible as possible with both GNU Octave and Matlab computing frameworks, offering general purpose, portable and freely available features for the scientific community. Mastrave is mostly oriented to ease complex modeling tasks such as those typically needed within environmental models, even when involving irregular and heterogeneous data series. Semantic array programming The Mastrave project attempts to allow a more effective, quick interoperability between GNU Octave and Matlab users by using a reasonably well documented wrap around the main incompatibilities between those computing environments and by promoting a reasonably general idiom based on their common, stable syntagms. It also promotes the systematic adoption of data-transformation abstractions and lightweight semantic constraints to enable concise and reliable implementations of models following the paradigm of semantic array programming. There are a couple of underlying ideas: library design is language design and vice versa (Bell labs); language notation is definitely a "tool of thought" (version), in the sense that there is a feedback between programming/mathematical notation and the ability to think new scientific insights. And perhaps ethic ones. Science and society Mastrave is free software, which is software respecting your freedom. As many other free scientific software packages, it is offered to the scientific community to also promote the development of a free society more concerned about cooperation rather than competitiveness, heading toward knowledge and culture freedom. Such a vision implies the possibility for motivated individuals to freely access, review and contribute even to the cutting-edge academic culture. This possibility relies on the development of tools and methodologies helping to overcome economic, organizational and institutional barriers (i.e. knowledge oligopolies) while systematically promoting reproducible research. This is a long-term goal to which the free software paradigm can and has been able to actively cooperate.
Math MatrixReal
Math::MatrixReal lets you manipulate NxN real matrices. Features include eigenvalues, eigenvectors, solving linear systems by various methods, determinants, many flexible ways to create matrices, and operator overloading.
MathEOS
This is a text editor for writing math lessons and providing tools for doing all the exercises from elementary school to junior high. The software is especially designed to fulfil the needs of disabled pupils, and pupils suffering from dyspraxia in particular. The program manages the child's documents like a notebook, organized with chapters, and separating lessons, exercises and evaluations, making it very easy to navigate through the documents.
MathGene
MathGene is a comprehensive JavaScript mathematics engine that delivers the ability to perform advanced numerical and symbolic mathematics processing of LaTeX expressions and send the output to pure HTML for rendering on a conventional web browser or via web server. MathGene has two modules: •mg_translate.js, which translates between LaTeX, HTML, and native MG format. •mg_calculate.js, which performs the calculations. mg_translate.js can be used without mg_calculate.js to perform mathematics rendering only. Both modules are required to perform calculations.
MathStudio
'MathStudio' is a project intended to make typing and resolution of mathematical expressions easier and more comfortable. Many other programs like this force the user to write input data using one row only (everything is typed at the same level, exponents and bases are on the same row) and use a lot of brackets to make the operation order explicit. Since this is very different from the math you do manually, the aim of this project is to reduce this gap providing both cross-platform libraries which can be embedded in other programs and a program, MathStudio, which demonstrates their usage.
Mathomatic
'Mathomatic' is a small, portable, general purpose symbolic math program that can solve, simplify, combine, differentiate, and compare algebraic equations. It can do standard, complex number, and polynomial arithmetic, and is designed to be as general as possible, with few options.
Maxima
Maxima is a fairly complete computer algebra system written in lisp with an emphasis on symbolic computation. It is the Common Lisp implementation of MIT's Macsyma system for computer based algebra.
Mcsim Heckert gnu.tiny.png
MCSim is a simulation and statistical inference tool for algebraic or differential equation systems. While other programs have been created to the same end, many of them are not optimal for performing computer intensive and sophisticated Monte Carlo analyses. MCSim was created specifically to perform Monte Carlo analyses in an optimized and easy to maintain environment.
MedianTracker
MedianTracker supports efficient median queries on and dynamic additions to a list of values. It provides both the lower and upper median of all values seen so far. Any __cmp__()-able object can be tracked, in addition to numeric types. add() takes log(n) time for a tracker with n items; lower_median() and upper_median() run in constant time. Since all values must be stored, memory usage is proportional to the number of values added (O(n)).
Metamath
Metamath is a language and a proof verifier for developing and verifying strictly formalized mathematical proofs, bundled with collaborated databases containing thousands of proven theorems including conventional results in logic, set theory, number theory, group theory, algebra, analysis, topology and various other topics. All proofs are in the form of Hilbert-style formulas. Included databases:
  • ZFC set theory
  • New Foundations set theory
  • Higher-order logic
  • Intuitionistic logic
  • Hilbert space
  • Quantum logic
Minfx
The minfx project is a Python package for numerical optimisation, being a large collection of standard minimisation algorithms. This includes the line search methods: steepest descent, back-and-forth coordinate descent, quasi-Newton BFGS, Newton, Newton-CG; the trust-region methods: Cauchy point, dogleg, CG-Steihaug, exact trust region; the conjugate gradient methods: Fletcher-Reeves, Polak-Ribiere, Polak-Ribiere +, Hestenes-Stiefel; the miscellaneous methods: Grid search, Simplex, Levenberg-Marquardt; and the augmented function constraint algorithms: logarithmic barrier and method of multipliers (or augmented Lagrangian method).
Mpc Heckert gnu.tiny.png
MPC is a complex floating-point library with exact rounding. It is based on the GNU MPFR floating-point library, which is itself based on the GNU MP library. This is a C library for the arithmetic of complex numbers with arbitrarily high precision and correct rounding of the result. It extends the principles of the IEEE-754 standard for fixed precision real floating point numbers to complex numbers, providing well-defined semantics for every operation. At the same time, speed of operation at high precision is a major design goal.
Mpfr Heckert gnu.tiny.png
The MPFR library is a library for multiple-precision floating-point computation with exact rounding. The computation is both efficient and has a well-defined semantics. It copies the good ideas from the ANSI/IEEE-754 standard for double-precision floating-point arithmetic.
Mpmath
Mpmath is a pure-Python library for multiprecision floating-point arithmetic. It provides an extensive set of transcendental functions, unlimited exponent sizes, complex numbers, interval arithmetic, numerical integration and differentiation, root-finding, linear algebra, and much more. Almost any calculation can be performed just as well at 10-digit or 1000-digit precision, and in many cases pmath implements asymptotically fast algorithms that scale well for extremely high precision work. If available, mpmath will (optionally) use gmpy to speed up high precision operations. If matplotlib is available, mpmath also provides a convenient plotting interface. Its features include:
  • Fair performance -- typically 10-100x faster than Python's decimal library
  • Transcendental functions -- all functions from Python's math and cmath modules, plus a few more like gamma, factorial, erf
  • Complex numbers -- with support for transcendental functions
  • Directed rounding -- floor, ceiling, down, up, half-down, half-up, half-even
  • Unlimited exponents -- no overflow or underflow
NMod nBody Modelling Toolkit
nMod nbody toolkit is a collection of tools designed to enable researchers to perform experiments using a particle-particle nBody model that runs on standard home computers.
The toolkit contains a particle-particle model, functions to enable the simulation of spacecraft flight, and an opengl viewer to display the resulting time series data.
NumExp
'NumExp' is a Gnome program that implements numeric methods and some mathematical solutions. It is implemented via a CORBA server and a text client.
NumberParser (Java)
NumberParser simplifies the usage of numeric types and extends the default mathematical support in Java. It is the second part of FlexibleParser. This Java version is a conversion of the code which I originally developed in C#.
Numdiff
Numdiff is a program with the capability to appropriately compare files containing numerical fields (and not only). By default, Numdiff assumes the fields are separated by white spaces (blanks, horizontal tabulations and newlines), but the user can also specify its list of separators. When you compare a couple of such files, what you want to obtain usually is a list of the numerical fields in the second file which numerically differ from the corresponding fields in the first file. Well known tools like diff, cmp or wdiff can not be used to this purpose: they can not recognize whether a difference between two numerical fields is only due to the notation or is actually a difference of numerical values. Moreover, you could desire to neglect all small numerical differences too. However, programs like diff and wdiff can not be used to ignore small numerical differences, since they do not even know what a numerical difference is.
ODOP:Spring
More than a spring calculator, ODOP:Spring is full-featured spring design software for engineering custom helical coil springs, including compression, torsion and extension springs. While certainly capable of analyzing the performance of an existing spring design, our open-source and free to use web app is at its best when used to develop solutions to difficult and highly constrained original design problems. Typical spring calculators perform design analysis, requiring users to make repeated inputs (independent variables of the design equations like wire diameter, coil diameter, number of coils and loads) until the desired outputs (dependent variables like deflections, stresses, weight, and estimated cycle life) are achieved. On the other hand, ODOP:Spring performs design synthesis to invert the dependent / independent relationships of the design equations and perform constrained optimization. You input specific goals, and ODOP:Spring returns the variable values that best meet those goals.
Octave Heckert gnu.tiny.png,
Octave is a high-level interpreted language that is specialized for numerical computations. It can be used for both linear and non-linear applications and it provides great support for visualizing results. Work may be performed both at the interactive command-line as well as via script files. N.B. The Octave language is quite similar to that of proprietary Matlab so that most programs are easily portable. There is support for editing both in Emacs.
Octave-ann
The octave-ann package wraps the ANN library, which provides data structures and functions for computing exact and approximate nearest neighbors on an arbitrarily high dimensional point set. This Octave add-on package is part of the Octave-Forge project.
Octave-interval
The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors. These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing. The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic.
OpenCalc , Heckert gnu.tiny.png
OpenCalc is terminal based open-source calculator.
OpenCircuits
OpenCircuits allows you to plan and simulate digital circuits in an easy-to-understand interface. It can be used for educational, personal or commercial purposes due to its LGPL licensing.
OpenPlaG
openPlaG is a PHP based function graph plotter for the use on websites. openPlaG allows the display of up to three function graphs, their derivative and their integral. It can compute several different functions.
OpenRK
The OpenRK - Open Randomness Kit library is a collection of pseudorandom numbers related routines for numerical computing for C and C++ programmers. It was developed from scratch in C to provide a modern and simple to use Applications Programming Interface (API), which helps in decreasing your development time and help you achieve better results. It is intended for a wide spread of users, from hobbyist programers to ordinary scientific users. Anyone who knows some C programming will be able to start using it straight-away.
Opennn
OpenNN is a class library written in C++ which implements neural networks. The library is intended for advanced users, with high C++ and machine learning skills. OpenNN provides an effective framework for the research and development of data mining and predictive analytics algorithms and applications. OpenNN is based on the most popular neural network model, the multilayer perceptron. The package comes with unit testing, many examples and extensive documentation. The library has been designed to learn from data sets. Some typical applications here are function regression (modelling), pattern recognition (classification) and time series prediction (forecasting). OpenNN is being developed by Intelnics, a company specialized in the development and application of neural networks.
Openscad
OpenSCAD is a software for creating solid 3D CAD objects. It focuses on CAD aspects rather than artistic ones. OpenSCAD is not an interactive modeller. Instead it is something like a 3D-compiler that reads in a script file that describes the object and renders the 3D model from this script. This gives the designer full control over the modelling process and enables him to easily change any step in the modelling process or make designes that are defined by configurable parameters.
Opmuse
A web application to play, organize and share your music library.


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.