Revolver and Notepad

The notepad is used for simple calculations such as 5+3*7^2,  ln(10) and the like. The main environment, the "revolver", consists of a series of so-called calculators. Each calculator can hold a formula and remember a number of settings. The <right-arrow>, <left-arrow> keys allow switching between and comparing neighboring calculators.
Calculators can also operate in Runge-Kutta mode, where they compute a solution curve to a differential equation.
Calculators are the base from where to generate plots or run numeric modules.
An independent feature are user defined functions:

page top

User defined Functions

- can have anything between 0 and 52 arguments
- can have anything between 1 and roughly 1000 values
- can call each other or themselves (up to 100 levels deep)
- short linear programs in a single formula
- several formulae in composite functions (see programming)
- special syntax for calling multivalued functions
- use global as well as local variables
- user defined constants and vectors

A single formula contains one or several commands, separated by semicola, forming a short
linear program:

                                  #auto a,b;  a= -quad(x)/2; b=1/(2*sqr(pi)); a*exp(b)

Functions of a composite class contain several formulae. Currently, there exist seven such classes:

• 2-formula objects
• n-formula objects
• Recursion objects
• Parameter integrals
• Finite sums
• Infinite sums
• Runge-Kutta functions
  

- 2-formula objects have a (third) decision formula checking a logical condition and passing
  execution to one of the computation formulae. These can invoke other user defined objects
  (branching)

- n-formula objects consist of a chain of several conditions each having its associated action
  component. The first action whose condition is found true, is executed. This amounts to an
  if...else if... construct as known from other programming languages.

- Recursion objects constitute a (while/until)-loop with two controls and separate formulae for
   initialization, the loop body, and computation of return value(s)

- Parameter integrals will at runtime invoke the Romberg procedure for numeric integration.
   Integrations can be nested by having parameter integrals call each other.

- Some functions are defined in terms of  parameter dependent sums. Both finite and infinite
  sums (the latter known as limits of series) can be installed as user functions  as well.
  At runtime, they will either perform "infinite" summation (i.e. summation until there is no
  detectable  further change) or invoke the convergence accelerator (see below).

- Runge-Kutta functions return the solution to a (system of) differential equation(s) for given
   initial values. Once installed, they can be called like ordinary functions.

Mathematical objects of considerable complexity have been built using several such components.
You'll find demos in the written documentation and the sample libraries. Self invoking functions
have been used to implement complicated combinatorial stuff such as different kinds of partition
numbers.

Version 0.92 introduces caches to speed up execution of self invoking functions. Just turning
a switch will add a cache to an existing function. You thus gain the speed of handcrafted
"imperative" code, while still enjoying the simplicity of functional programming.

- User functions can each carry their own page of comments
- Organize related user functions in a library for permanent installation.
   Create any number of such library files.
- Leave provisional functions in Desktop.lib until deciding otherwise. It is the junk-library saving
   the actual changes of every session.

Once installed, a user function will self-assemble and execute when called. It does not play a role
to which library it belongs. Just issue a call such as

myfunc(1,x,17)
myfunc#5(x,y)
myrandomfunc
myconstant
myvector#3

- searching all libraries for this function
- finding all other functions invoked by this function (etc.)
- compiling and linking all components
- kicking off computation
- displaying the numeric result.

Then press <v> to see a list of all user components involved.

- shows a list of the user defined functions of all libraries
- offers several sorting modes for that list
- direct access to each function for viewing, editing, copying, moving etc.
- text search feature
- grep-like search feature (scanning formulae and comments of all functions)
- callfinder search feature

Every formula is compiled prior to execution to form intermediate code. The components are linked by object pointers in this code. The linked bundle is then executed by a run-time system reminding of FORTH and optimized for speed. You will benefit when running plots or Monte Carlo simulations.

In addition to standard scientific functions that are on most pocket calculators (such as ln(), exp(), the inverse hyberbolic sine etc.) many others are available here at syntax level, so the parser will reckognize them. Most are precise to 14 digits for "reasonable" input. Of such "advanced" functions, just the predefined ones are in the following table. Others are supplied in the distribution libraries. See the function reference for a more complete list.
 

argeo(a,b)	arithmetic geometric mean
atn2(x,y)	argument of a complex number
Ber(n)	Bernoulli numbers
Binomial(n,p,a,b)	cumulative Binomial distribution
Bj0(x) Bj1(x)
Bjn(x,y)  By0(x)	Bessel functions
By1(x) Byn(x,y)
det(...)	matrix determinant
ellF(k,b)	elliptic integral of 1st kind
ellK(k)	complete elliptic integral of 1st kind
Eul(n)	Euler numbers
fact(x)	factorial
gam(x)	gamma function
gam1(x), gam2(x), gam3(x)	derivatives of the gamma function
harm(x)	harmonic sum
Hgeo(N,M,n,a,b)	cumulative hypergeometric distribution
inv##(...)	inverse of a matrix
Legendre(x,n)	Legendre polynomial
lnfac(n)	logarithm of factorial (for large input numbers)
lngam(x)	logarithm of the gamma function (for large input numbers)
mama##(...)	product of square matrices
mavect##(...)	matrix vector product
ncr(n,k)	binomial coefficient
phi0(x)	Gaussian error integral
Poly(x,an,...,a1,a0)	polynomial (using Horner's scheme)
Pser(x,a0,a1,...)	power series (using Horner's scheme)
psi(x)	psi function
psi1(x),psi2(x),psi3(x)	derivatives of the psi function
rand(0)	random numbers
solve##(...)	solve linear equation system
symevals##(...)	eigenvalues of a symmetric matrix
symevectors##(...)	eigenvectors of a symmetric matrix
Tangent(x)	higher tangent derivatives at x=0
Tsch(x,n)	Chebychev polynomial
Tser(x,a0,a1,...)	series in Chebychev polynomials (fast computation scheme)
zeta(x)	Riemann zeta function

This distribution contains about 500 additional user defined functions in separate library files. Such as:

Unit conversions
Physical and astronomical constants
Complex numbers
Complex roots of polynomials up to 4^th order
Characteristic polynomial, eigenvalues
Applications to plane geometry
Applications in 3-dimensional space (simplices)
A few textbook problems in linear algebra
A few combinatorial / stochastic applications
Random numbers and -vectors
Geodesic travel routes on Earth
Time parametrization of Keplerian orbits
Integer utilities
A few diophantic applications
Space filling curves

Use the database to browse the library files. Each object is commented in German and English.
You can build your own applications on top of these, but also modify them and improve their
implementation.

While the libraries distributed with the executable package are mainly demos to the program's capabilities, there are more specialized libraries available for download on a separate page. Right now there is one dealing with multidimensional numeric integration on several types of domains, and with tough cases (infinity limits, poles) of one dimensional numeric integration.

- screenplots are generated instantly
- use them as an assist for search procedures
- edit the plot windows by drawing mouse frames
- create printable plots from screenplot primers
- add curves and keep multiple views without limitation
- zoom into the details
- design your colored plot on the screen, then print it
- diagram delivery onto your Windows installed printer
- include simulated graph paper (true metric units) in the printout
- exports diagrams as -.GIF or -.BMP files for publication on the internet
- both simple and parametric plots supported on all levels
- use extra clipping formulae to mask out unwanted parts of the curve(s)

- enter your formulae into multiple calculators, each having its own plot- and derivative setting
- choose value-mode, 1st, 2nd, 3rd  numeric (partial) derivative, curvature mode or...
- ...apply a user defined differential operator
- compare related formulae (match-precision display)
- numeric integration by the Romberg method. Full 15-digit precision if the curve is benign.
  Precision estimates otherwise.
- universal search feature (bisection method). Adjust settings such as to find zeroes, poles, extremal
  points, points of inflection or extremal curvature, or the domain limits. Solve non-linear
  equations f(x)=C.  Search cross-sections in multi-argument or multi-value situations. Watch the other
  data change as you move along.
- create random functions and run Monte Carlo simulations, finding areas, volumes and probabilities
- use several kinds of random points and -vectors from RANDOM.LIB
- use linear equations and matrix inversion at syntax level by calling solve##(..) or inv##(..)
   (matrix size limited only by stackspace)
- use the nonlinear minimizer for finding extremal points of  functions of up to 52 unknowns
   ---> more on this feature
- use the solver for nonlinear equation systems of up to 52 unknowns
  ---> more on this feature
- use the convergence accelerator for instant computation of series limits, even if convergence is too
  slow to be waited for in conventional summation. The feature is good for alternating and fourier series
  as well, where it returns full precision results no matter how slowly the series converges.
- if your result is 1.64497041420118, it may escape your attention that this is precisely 278 / 169. But
  press <F3>, and the fraction recognizer performs "reverse engineering" of the fraction's enumerator
  and denominator, from the decimal form. Recognizes every relevant fraction and some quadratic
  irrationals, too, such as (sqr(3)+5) / 7.
  Runge-Kutta mode is available within user functions, calculators and plots. It computes the solution
  curve to a given initial-value problem. The solution curve's data are cached for faster execution. In the
  plot-environment,  new initial values can be set for certain Runge-Kutta curves by clicking on the screen.

Compiler: Visual C++ vers. 6.0
Program size: about 1,200,000 bytes
OS:  runs on all 32 bit Windows editions
Character set: OEM
Double threaded application, where thread1 deals with the window and the message flow,
while thread2 does all the computations
Processor stack of thread2:  initially 60 kilobytes
Precision: 8-byte floating point numbers, 15 digit mantissa, -300 < exponent < 300
Computation stack: 22000 squares each holding each an 8-byte float
Maximum function call depth:  100

- Symbolic calculation is not supported.
- Precision is limited to 15 decimals.
- Variables and arguments must be single characters - which limits their number to 52.
- Number of arguments and values are fixed for each user function, must be known
  at compile time
- No support for arrays
- No BASIC, PASCAL etc.
- The maximum length is set to:
    30 characters for names
    1040 characters for formulae
    1500 characters for comments
- No support for 3D plots and implicit plots
- No directory change at runtime