Numeric Operations

Numbers may be stored internally in several different ways, which can have a noticeable effect on the performance of operations requiring numeric parameters. These are:

• A string type that is a valid number. If referenced when a numeric is required, it has to be parsed to check that it is a valid number and converted to a numeric type.
• A binary number which can usually be used directly when a numeric is required and is therefore the most efficient.
• A string number that causes any calculation to be performed using string number math routines. These are many times slower than their binary equivalents.

Binary numbers are stored together with a scale value. This scale value can range from zero to the maximum scaling factor, or precision, in force when the number is generated. Precision is dynamic and can be changed at any point in the program (via the PRECISION statement). The scale value of a variable is more difficult to predict than previous releases. However, in general, numbers are less likely to overflow as the scale value is only as high as is required to hold the number.

The scale value of the result of a calculation depends both on the scale values of the operands and the type of operation:

• Add and Subtract generate a result that has a scale value that is the maximum of the scale values of the operands (regardless of the current precision).
• Multiply generates a result that has a scale value that is the addition of the scale values of the operands, unless this is greater than the current precision, in which case the number is scaled down to the current precision.
• Divide generates a result that has a scale dependent on the number of decimal places of the result, with a maximum scale value of the current precision.
• Trigonometric and Logarithmic functions calculate at a fixed precision of 5. If this is larger than the current precision, the result is scaled down to the current precision.

Operations that require integer parameters are able to use numbers with a zero scale value directly, but numbers with a non-zero scale factor have to be unscaled first. It is therefore preferable in this case to avoid operations that generate numbers with decimal places.

If the value of a binary number, or the result of binary arithmetic, is of a magnitude that cannot be stored in 48 bit two's complement binary (approximately 14 decimal digits), it is converted to a string number and calculations are performed using string number math routines. If the final result of an operation performed using string number math routines can be stored in 48 bit two's complement binary within the limits of the current precision, it is converted and stored as binary.

Considerations for Efficiency

• Always use the simplest operators (X=X+X  instead of X=X*2, X=X*X  instead of X=X^2, and so on).
• If an arithmetic expression is used more than once, assign it to a variable and use this variable in place of the expression so that it only has to be evaluated once. For example, in FOR I=1 TO x, where x is an expression or non-integer descriptor, assign x to a variable and substitute it for x. This is especially important if the expression is complicated, may have to convert operands to the correct type, or contains functions.
• Complex expressions evaluate faster than less complex expressions with intermediate results. (Use HYPOTENUSE=SQRT(A*A+B*B)  instead of Q=A*A; R=B*B; S=Q+R; HYPOTENUSE=SQRT(S)).
• If using variables containing constants, use EQUATE rather than assignment statements.