**LN (1)** Log to the base e, where e = 2.7183 corrected to four
decimal places. Input must be greater than zero.
**EXP (1)** Exponential value. Raises e to the given power.

**SORT (1)** Square root. No negative values accepted.

**SIN (1)** Sine of an angle.

**COS (1)** Cosine of an angle.

**TAN (1)** Tangent of an angle. Organiser registers an error if the angle
yields an infinite tangent, e.g. PI/2 radians (90 degrees), 3PI/2* *rads, 5PI/2 rads,
etc.

**ATN (1)** Arctangent. The angle whose tangent is given.

**ABS (1)** Absolute value. Converts a negative number to a positive one. e.g.
ABS(-5)=5.

**INT (1)** Integer value. Rounds down to whole number. e.g. INT(1.8451)=1

**DEG (1)** Converts radians to degrees.

**RAD (1)** Converts degrees to radians.

**MOD (2)** Modulo. Calculates the remainder after dividing the first parameter
by the second. e.g. MOD(20,8) is translated into 20-8*INT(20/8) which works out as 4, 50 that
MOD(20,8)=4. The second parameter must not be equal to zero.

**MIN (1to 42)** Minimum. Finds the smallest of the values given.

**MAX (1 to 42)** Maximum. Finds the greatest of the values given.

**FAC (1)**Factorial e.g. FAC(5) is 5*4*3*2*1, so that FAC(5)=120. Input
must lie between zero and 69.

**SGN (1)** Sign. Looks at the sign of the given number. Its
result is +1 if the number is positive, -1 if it is negative, and zero if it
is zero.

**ROUND (1)** Rounds input to nearest integer. (0.5 is rounded up)

**MEAN (1 to 42)** Calculates the mean of the
input values.

**STDEV (1 to 42)** Standard Deviation (n-1
basis) of the input values.

**PI** Needs no parameters. Produces the value
of the constant pi, which is 3.1416 (corrected), to be used in calculation like any other
number.

**** (0)** Simply type two multiplication signs together to call
this operation. Raises the number to its left to the power given by the number to its
right. e.g. 3**2 = 9.

**RND (2)** Random number generator. Returns a
random number in the range bounded by the two inputs, inclusive of the greater but
excluding the lesser. For instance, RND(5,20) may produce any number from 6 to 20
inclusive. These random numbers are random in terms of distribution, but actually depend
on a mathematical formula.

**RAND (1)** Randomise. Sets the starting value for the formula which
generates random numbers. This determines the series of random numbers that will result
from subsequent uses of RND. For example, an input RAND(2) always results in the same
series of random numbers, which is different from that resulting from say RAND(4). RAN
D(0) results in an arbitrary starting value for the random number generator, and will give
a different series every time.

**ENG (1)** Engineering Format. Sets format of output to a number between
1 and 999 times 10 to a power which is a multiple of three. For example, 0.56 is expressed
as 560 E-3, and 56780000 as 56.78 E6. To set this format on, type in ENG(i) and press
EXECUTE. To set it off, type ENG(0) and press EXECUTE. The current setting is active even
when running procedures unless your procedure contains a statement to over-ride it.

**FIX (1)** Sets the number of places after
the decimal point for any subsequent output. A negative input with FIX clears the last
setting leaving the number of decimal places open.

NOTE — Both ENG and FIX return their previous status as a result.

First select 'CALC'. Now type the name of the
function you want to use, followed by the correct number of parameter values enclosed in
brackets. Press **EXECUTE** to calculate the result.

A parameter value can be a number or the name of a function or procedure which results
in a number. When you need to enter two or more parameters you should separate each one
from the next by a comma, e.g.

**MIN(7,9,4,PI,2,1 0)**

Functions can be linked by arithmetical operators, just as numbers in a basic
arithmetical calculation. Calculations such as:

**COS(PI/3)*(SIN(2*PI)+LN(2))-1.512*COS(10)**

are well within Organiser's capabilities.

An outstanding feature of the Utility pack is that it allows you to do calculations
which use the result of one function or procedure as a parameter value for another, so
that calculations may consist of functions stacked within each other like a set of Chinese
boxes.