Free high precision calculation software for linux

high-resolution-timer is a library with Java and C++ wrappers to implement high . These timers can be used, for example, to count the ticks when doing performance analysis.
high-resolution-timer exploits the system dependent timers/clocks and provides a timer-like interface to the same. The attached file has build scripts for Linux and Solaris. There is also a Java wrapper over the library, which uses JNI to use the timer interfaces.
Enhancements:
- The library is a basic approach to design a base for the performance library.
- It has not yet taken into consideration the details of library preloads, etc.
- At load time, the library initializes itself with the timer with the least avg resolution.
- At unload time, the library cleans up by freeing any allocated memory.
- The library provides a getErrorMessage function to let the user know the detailed report of the error.
- The library exports start / stop JNI wrappers .

The FinerEdge Calculation Solution is a modern Java, ISO and XML standards-based, customizable financial amortization calculation system designed for financial institutions, financial software vendors, and application service providers. The FinerEdge Calculator is a single source financial calculation solution from the Web to the Desktop to the Mainframe.

FinerEdge Calculator project handles all types of loans, bonds, annuities and other investments using all of the proper calculation methods and terms for each of the different types of cash flows. In addition, new calculation methods and terms can visually be added to FinerEdge Calculator and immediately leveraged across your entire enterprise and web offerings, all without any programming! In turn, this enables the easy creation and servicing of custom, hybrid financial products that keep you ahead of the competition.

The MPFR library is a C library for multiple-precision floating-point computations with exact rounding (also called correct rounding). It is based on the GMP multiple-precision library.

The main goal of MPFR is to provide a library for multiple-precision floating-point computation which 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 (53-bit mantissa).

MPFR is free. It is distributed under the GNU Lesser General Public License (GNU Lesser GPL). The library has been registered in France by the Agence de Protection des Programmes under the number IDDN FR 001 120020 00 R P 2000 000 10800, on 15 March 2000.

This license guarantees your freedom to share and change MPFR, to make sure MPFR is free for all its users. Unlike the ordinary General Public License, the Lesser GPL enables developers of non-free programs to use MPFR in their programs. If you have written a new function for MPFR or improved an existing one, please share your work!

HPC Challenge is a high performance benchmark suite. The HPC Challenge consists of basically 7 benchmarks:
1. HPL - the Linpack TPP benchmark which measures the floating point rate of execution for solving a linear system of equations.
2. DGEMM - measures the floating point rate of execution of double precision real matrix-matrix multiplication.
3. STREAM - a simple synthetic benchmark program that measures sustainable memory bandwidth (in GB/s) and the corresponding computation rate for simple vector kernel.
4. PTRANS (parallel matrix transpose) - exercises the communications where pairs of processors communicate with each other simultaneously. It is a useful test of the total communications capacity of the network.
5. RandomAccess - measures the rate of integer random updates of memory (GUPS).
6. FFTE - measures the floating point rate of execution of double precision complex one-dimensional Discrete Fourier Transform (DFT).
7. Communication bandwidth and latency - a set of tests to measure latency and bandwidth of a number of simultaneous communication patterns; based on b_eff (effective bandwidth benchmark).
Compiling:
The first step is to create a configuration file that reflects characteristics of your machine. The configuration file should be created in the hpl directory. This directory contains instructions (the files README and INSTALL) on how to create the configuration file. The directory hpl/setup contains many examples of configuration files. A good approach is to copy one of them to the hpl directory and if it doesnt work then change it. This file is reused by all the components of the HPC Challange suite.
When configuration is done, a file should exist in the hpl directory whose name starts with Make. and ends with the name for the system used for tests. For example, if the name of the system is Unix, the file should be named Make.Unix.
To build the benchmark executable (for the system named Unix) type: make arch=Unix. This command should be run in the top directory (not in the hpl directory). It will look in the hpl directory for the configuration file and use it to build the benchmark executable.
Configuration:
The HPC Challange is driven by a short input file named hpccinf.txt that is almost the same as the input file for HPL (customarily called HPL.dat). Refer to the file hpl/www/tuning.html for details about the input file for HPL. A sample input file is included with the HPC Challange distribution.
The differences between HPL input file and HPC Challange input file can be summarized as follows:
- Lines 3 and 4 are ignored. The output always goes to the file named hpccoutf.txt.
- There are additional lines (starting with line 33) that may (but do not have to) be used to customize the HPC Challenge benchmark. They are described below.
The additional lines in the HPC Challenge input file (compared to the HPL input file) are:
Lines 33 and 34 describe additional matrix sizes to be used for running the PTRANS benchmark (one of the components of the HPC Challange benchmark).
- Lines 35 and 36 describe additional blocking factors to be used for running PTRANS benchmark.
Just for completeness, here is the list of lines of the HPC Challanges input file with brief descriptions of their meaning:
- Line 1: ignored
- Line 2: ignored
- Line 3: ignored
- Line 4: ignored
- Line 5: number of matrix sizes for HPL (and PTRANS)
- Line 6: matrix sizes for HPL (and PTRANS)
- Line 7: number of blocking factors for HPL (and PTRANS)
- Line 8: blocking factors for HPL (and PTRANS)
- Line 9: type of process ordering for HPL
- Line 10: number of process grids for HPL (and PTRANS)
- Line 11: numbers of process rows of each process grid for HPL (and
PTRANS)
- Line 12: numbers of process columns of each process grid for HPL
(and PTRANS)
- Line 13: threshold value not to be exceeded by scaled residual for
HPL (and PTRANS)
- Line 14: number of panel factorization methods for HPL
- Line 15: panel factorization methods for HPL
- Line 16: number of recursive stopping criteria for HPL
- Line 17: recursive stopping criteria for HPL
- Line 18: number of recursion panel counts for HPL
- Line 19: recursion panel counts for HPL
- Line 20: number of recursive panel factorization methods for HPL
- Line 21: recursive panel factorization methods for HPL
- Line 22: number of broadcast methods for HPL
- Line 23: broadcast methods for HPL
- Line 24: number of look-ahead depths for HPL
- Line 25: look-ahead depths for HPL
- Line 26: swap methods for HPL
- Line 27: swapping threshold for HPL
- Line 28: form of L1 for HPL
- Line 29: form of U for HPL
- Line 30: value that specifies whether equilibration should be used
by HPL
- Line 31: memory alignment for HPL
- Line 32: ignored
- Line 33: number of additional problem sizes for PTRANS
- Line 34: additional problem sizes for PTRANS
- Line 35: number of additional blocking factors for PTRANS
- Line 36: additional blocking factors for PTRANS
Enhancements:
- This version contains many bugfixes, major features, and minor enhancements, many of which were contributed by users.
- The major focus of this release was to improve accuracy of the reported performance results and ensure scalability of the code on the largest supercomputer installations with hundreds of thousands of computational cores.

Plutimikation is a math learning game for children. It trains basic calculation skills like multiplication in the number range between 1 and 100.
Its simple, it works and my daughter likes it. Its free software written for the KDE desktop.
Enhancements:
- First public release: Plutimikation 0.1.

Simulation::Sensitivity is a general-purpose sensitivity analysis tool for user-supplied calculations and parameters.

SYNOPSIS

use Simulation::Sensitivity;
$sim = Simulation::Sensitiviy->new(
calculation => sub { my $p = shift; return $p->{alpha} + $p->{beta} }
parameters => { alpha => 1.1, beta => 0.2 },
delta => 0.1 );
$result = $sim->run;
print $sim->text_report($result);

Simulation::Sensitivity is a general-purpose sensitivity analysis tool. Given a user-written calculating function, a "base-case" of parameters, and a requested input sensitivity delta, this module will carry out a sensitivity analysis, capturing the output of the calculating function while varying each parameter positively and negatively by the specified delta. The module also produces a simple text report showing the percentage impact of each parameter upon the output.

The user-written calculating function must follow a standard form, but may make any type of computations so long as the form is satisfied. It must take a single argument -- a hash reference of parameters for use in the calculation. It must return a single, numerical result.

CONSTRUCTORS

new

my $sim = Simulation::Sensitivity->new(
calculation => sub { my $p = shift; return $p->{alpha} + $p->{beta} }
parameters => { alpha => 1.1, beta => 0.2 },
delta => 0.1 );

new takes as its argument a hash with three required parameters. calculation must be a reference to a subroutine and is used for calculation. It must adhere to the usage guidelines above for such functions. parameters must be a reference to a hash that represents the initial starting parameters for the calculation. delta is a percentage that each parameter will be pertubed by during the analysis. Percentages should be expressed as a decimal (0.1 to indicate 10%).

As a constructor, new returns a Simulation::Sensitivity object.

Gcalctool is the default GNOME desktop calculator.

Gcalctool has Basic, Financial and Scientific modes. Internally it uses multiple precision arithmetic to produce results to a high degree of accuracy.

Calctool is a desktop calculator. It has been designed to be used with either the mouse or the keyboard. It is visually similar to a lot of hand-held calculators. There are financial, logical and scientific modes. Similar operations are color coded. Some of the calculator keys have menu marks. This indicates that there is a menu associated with that key.

One of the most important things to remember about calctool is that calculations are performed from left to right, with no arithmetic precedence. If you need arithmetic precedence, then you should use parentheses.

Internal arithmetic is now done with multi-precision floating point numbers. Accuracy can be adjusted from zero to nine numeric places in fixed notation, but numbers can be displayed in engineering and scientific notation as well. The calculator reverts to scientific notation when the number is larger than the display would allow in fixed notation. The base of operation can be changed between binary, octal, decimal and hexadecimal. Numbers are initially displayed in fixed notation to two numeric places, in the decimal base.

There are ten memory registers. Numbers can be stored or retrieved in these locations, and arithmetic can be performed upon register contents.

The display windows contains the current numerical value plus the current base and trigonometric type. There are also indicators which show if the hyperbolic and inverse function switches are set, and which numerical mode is currently in operation. If an operation needing more than one numerical input is partially complete, the operation is also displayed in this window as a reminder.