Further information

Interesting facts and backgrounds

Overview

NumeRe: Framework für Numerische Rechnugen is designed as a numerical environment that can solve mathematical and physical problems. Each data set is considered as a table, which can be evaluated for further analysis.

The basis for NumeRe is a syntax as simple as possible, which may remind of known programs like Gnuplot.

System requirements

NumeRe: Framework für Numerische Rechnungen was developed for Microsoft Windows® and is (so far) only executable on this OS.

Operating system: MS-Windows® (x86 or x64, Windows 7 or higher)
Keyboard and mouse

Installation

NumeRe is delivered as an installer that takes care of all the necessary steps to be done until it is ready to run. There are two versions here:

a stable version. This installer needs administrator rights and may link NumeRe completely to the operating system (but this can be deselected). Advantages are the better interaction with the operating system in the form of file icons and "open with" links. Disadvantage: NumeRe is no longer portable with this
a portable version. This installer can be run with normal user rights. It does not create file shortcuts and the installed NumeRe version can be moved arbitrarily afterwards.

To install a newer version of NumeRe, it can simply be installed over the old version. It is not necessary (and not recommended) to uninstall NumeRe beforehand.

History

NumeRe was born on a voluntary basis from a tutorial of physics. The development went as follows:

Original development

The development started in September 2013 in its original form under the somewhat cumbersome name Basisframework für numerische Rechnungen and was intended as a first insight for first semester physics students into the C++ programming language. It was intended to present how the tasks, which should have been performed using GNU Octave, look like when they are directly converted into source code.

It soon became apparent that the core of this program is capable of much more than just evaluating data tables. Consequently, the development was continued and finally resulted in the development of this framework.

Further development

Soon after the move to further development (around mid-October 2013), the renaming to the current name NumeRe: Framework für Numerische Rechnungen followed. While the beginning of the development happened with the IDE Orwell Dev-C++, the switch to Code::Blocks took place at the end of October, as the former IDE struggled with bugs that made working with large projects almost impossible.

At the beginning of November the muParser library was added with version v 0.5.1 as a command line parser for mathematical expressions and at the end of December the MathGL library was integrated with version v 0.9.0, so that from now on also graphic plots of functions and data sets were possible.

User Interface

The right side shows a screenshot of a typical NumeRe session. Here the file navigator, which provides an overview of the files in the default paths, can be seen on the left. At the top right is the editor and at the bottom right is the console, both of which support syntax highlighting and autocompletion. The editor also displays tooltips to the syntax elements under the mouse pointer. It also supports bracket and text block highlighting, as well as other functions to make working with scripts and procedures easier.

1D-, 2D- & 3D-Plotting

NumeRe is equipped with a versatile plot algorithm. This can graph functions and data sets, and the generated graph is always written to an external file. (A default viewer can be set up which then loads this file automatically, e.g. Irfanview).

The plotting algorithm is started by one of the following commands, each of which activates a different plotting style: plot, plot3d, mesh, mesh3d, surf, surf3d, dens, dens3d, grad, cont, cont3d, vect & vect3d. Thereby plot* generates line and data point plots, mesh* grid plots of surfaces, surf* surface plots, dens* density plots, grad a gradient plot, cont* contour line plots and vect* vector field plots. The latter should always be used with caution, however, as in many cases they do not produce a very good representation of the vector field on the first try and require some fine tuning.

For example, the plot shown a few lines above can be drawn with the command

|<- plot cos(2*x)*exp(-x/2), exp(-x/2), -exp(-x/2) -set grid box [0:10]

reproduce. For each function (separated by commas) a separate curve with its own color and legend is created. The number of different colors and line styles is limited to 14 and shown on the right. After this number the colors and styles of the curves are repeated, but it is probably only in very few cases useful to draw more than 14 curves in one plot.In this case the possibility to put several curves in one single plot is shown to increase the information content of the same even more.

The meshgrid shown on the left is created by the mesh command in the following variant:

|<- mesh cos(_pi*x) + sin(_pi*y) -set box grid [0:_pi,0:_pi]

Here the constant _pi already mentioned above is used for the numerical value of PI for the x and y plot interval boundaries.

Syntax

The syntax of NumeRe is divided into two main categories: mathematical expressions and command syntax. Both will be discussed in more detail here.

Syntax of mathematical expressions

The syntax of mathematical expressions is probably the more intuitive of the two syntaxes, since the input is in principle little different from input to a calculator, which can handle more than the standard arithmetic operations. NumeRe of course uses the correct priority order of mathematical operators, as mentioned above, but care should be taken to use correct bracketing especially for fractions (since NumeRe itself cannot handle the concept of a fraction). So in general e.g.

|<- a / b*c != a / (b*c)

as NumeRe will confirm for a,b,c != 0 and c != 1.

Another difference is the parallelism of the mathematical parser: theoretically, it can evaluate any number of values at the same time (in reality, of course, this is limited among other things by the maximum length of a string, but this is 4.2949673 * 109 characters, which is slightly more than 4 billion). To have several expressions evaluated in parallel, they must be entered separated by commas:

|<- EXPRESSION_1, EXPRESSION_2, ..., EXPRESSION_n

Apart from that, NumeRe understands the meaning of the following mathematical (* + - / ^ = ( ) %) and logical operators (== != > >= < <= & && | || ! COND ? TRUE_VALUE : FALSE_VALUE). While the former are relatively obvious (^ is used to denote an exponent, e.g. x^2 for x2, and % is the modulo operator), the logic expressions probably need a brief explanation:

== "equal"
!= "not equal to"
> "greater than"
>= "greater than or equal to"
< "less than"
<= "less than or equal to"
& "binary and" (compares the bits one by one)
&& "and"
| "binary or" (compares the bits one by one)
|| "or"
||| "either or" (exclusive or)
! "not"
COND ? TRUE_VALUE : FALSE_VALUE "if COND is true, then TRUE_VALUE, otherwise FALSE_VALUE".

The return value of logical expressions is 0 as FALSE and 1 as TRUE and is also interpreted in the same way in logic expressions. (In addition to 1, all other values not equal to 0 within logical expressions are also a TRUE value).

Command syntax

The syntax of NumeRe commands follows the following scheme in every case:

|<- COMMAND [EXPRESSION] [-PARAMETER[=VALUE] [OPTIONS]]

This can also be expressed by the following "mnemonic", which illustrates the order of command, expression, and parameters: "Perform an action [on something] using the following parameters."

The information in square brackets is not present for every command. This can be seen well in the following examples:

|<- load samples/data

|<- help

|<- help integrate

|<- find arccos acos

|<- integrate cos(x)*exp(-x) -set x=0:2_pi

|<- set -loadpath=data/import

|<- grad exp(-norm(x,y)^2/10) -set [-10:10,-10:10] pcont fcont hires=medium

To reduce error-proneness with this syntax structure, the order of the options and the parameter can be changed as long as they are separated from the command by a preceding minus sign. However, if an expression follows the command, the set of options must begin with the parameter -set (this can also be replaced by "--").