6.7 Floating point variables

-----------------------------

6.7.1 Format of floating point variables

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Floating-point values in C-- are represented as type 'float'. This

type corresponds to a single-precision floating point number (in Pascal

or Fortran).

The format for representing floating-point data includes three

fields: sign, magnitude, and order. The sign is defined by the the first

significant bit. The magnitude field contains the significant bits of the

number, and the exponent field contains degree 2 and defines the scaling

multiplier for the magnitude.

31 30.....23 22........0

| | | | |

| | | -------------- - magnitude field

| ------------------------ - exponent field

-------------------------- - sign bit

6.7.2 Floating point constants

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The compiler distinguishes a floating point number from an integer

by the presence of a decimal point. A floating point number must start

with a number from 0 to 9 or a minus sign. It may also contain an

exponent factor (power of ten), which is separated from the number by 'e'

or 'E'.

0.98

-15.75

3.14e2

1.234567E-20

6.7.3 Range of permissible values

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Real numbers of float type can range from 3.37E38 to -3.37E38. The

values closest to zero are 1.17E-38 and -1.17E-38. There is no point in

writing a floating point number with unary precision greater than 8. The

scaling factor can be +38 to -38.

6.7.4 Mathematical operations

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The compiler support four primary operations on variables of type

float: addition, subtraction, multiplication and division. It also

supports increment (var++ increase by 1), decrement (var-- - decrease by

1), sign change (-var), and exchange of values (var1<>vars). The other

mathematical operations are to be performed later, or were already

performed in external libraries. Values of float variables can be

calculated using variables of other types which are automatically

converted to float type.

NOTE: The component mathematical operations are executed in the order in

which they were written, regardless of the usual mathematical rules.

6.7.5 Transformations of types

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

For mathematical operations which produce variables of type float,

all other types of operands are converted to float type before

calculating. When assigning another type of value to a float type

variable, it is also transformed to float type.

If during integer calculations one of the operands is a variable of

type float, the integral part of it will be separated out and will take

part in the calculations. When assigning a float-type value to an integer

variable, the integer part of it is also separated out and assigned an

integer variable.

6.7.6 Comparison operators

~~~~~~~~~~~~~~~~~~~~~~~~~~~

If during a comparison operation the left operand is a variable or an

expression of type float and the right operand is an integer, the integer

will be converted to the type float. If the left operand is an integer or

variable and the right operand is of type float, the integer part of the

right operand will be separated out and will take part in the comparison.

6.7.7 Comparing variables of type float with a 32-bit register

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Signed, unsigned and real data can be stored in registers. By default

unsigned numbers are considered to be stored in registers. When comparing

values of type float with 32-bit register, the type of data stored in the

register can be indicated using the modifiers 'signed', 'unsigned', or

'float'. For example:

float f=1.0;

void PROC()

{

IF( f < signed ECX) // signed number stored in register ECX

IF( unsigned EBX > f) // unsigned number stored in register EBX

IF( f == float EAX ) // float-type number stored in register EAX

}

NOTE: For comparison operations involving variables of float type, the

contents of register AX will be destroyed.