11.1.5 Floating point types

C# supports two floating-point types: float and double. The float and double

types are represented

using the 32-bit single-precision and 64-bit double-precision IEC 60559

formats, which provide the

following sets of values:

Chapter 11 Types

?Positive zero and negative zero. In most situations, positive zero and

negative zero behave identically as

the simple value zero, but certain operations distinguish between the two (?

4.7.2).

?Positive infinity and negative infinity. Infinities are produced by such

operations as dividing a non-zero

number by zero. [Example: For example, 1.0 / 0.0 yields positive infinity,

and .1.0 / 0.0 yields

negative infinity. end example]

?The Not-a-Number value, often abbreviated NaN. NaNs are produced by

invalid floating-point

operations, such as dividing zero by zero.

?The finite set of non-zero values of the form s ?m ?2e, where s is 1 or

-1, and m and e are determined

by the particular floating-point type: For float, 0 < m < 224 and -149 = e

= 104, and for double,

0 < m < 253 and -1075 = e = 970. Denormalized floating-point numbers are

considered valid non-zero

values.

The float type can represent values ranging from approximately 1.5 ?10-45

to 3.4 ?1038 with a precision

of 7 digits.

The double type can represent values ranging from approximately 5.0 ?

10-324 to 1.7 ?10308 with a

precision of 15.16 digits.

If one of the operands of a binary operator is of a floating-point type,

then the other operand must be of an

integral type or a floating-point type, and the operation is evaluated as

follows:

?If one of the operands is of an integral type, then that operand is

converted to the floating-point type of

the other operand.

?Then, if either of the operands is of type double, the other operand is

converted to double, the

operation is performed using at least double range and precision, and the

type of the result is double

(or bool for the relational operators).

?Otherwise, the operation is performed using at least float range and

precision, and the type of the

result is float (or bool for the relational operators).

The floating-point operators, including the assignment operators, never

produce exceptions. Instead, in

exceptional situations, floating-point operations produce zero, infinity,

or NaN, as described below:

?If the result of a floating-point operation is too small for the

destination format, the result of the

operation becomes positive zero or negative zero.

?If the result of a floating-point operation is too large for the

destination format, the result of the

operation becomes positive infinity or negative infinity.

?If a floating-point operation is invalid, the result of the operation

becomes NaN.

?If one or both operands of a floating-point operation is NaN, the result

of the operation becomes NaN.

Floating-point operations may be performed with higher precision than the

result type of the operation.

[Example: For example, some hardware architectures support an .extended. or

.long double. floating-point

type with greater range and precision than the double type, and implicitly

perform all floating-point

operations using this higher precision type. Only at excessive cost in

performance can such hardware

architectures be made to perform floating-point operations with less

precision, and rather than require an

implementation to forfeit both performance and precision, C# allows a

higher precision type to be used for

all floating-point operations. Other than delivering more precise results,

this rarely has any measurable

effects. However, in expressions of the form x * y / z, where the

multiplication produces a result that is

outside the double range, but the subsequent division brings the temporary

result back into the double

range, the fact that the expression is evaluated in a higher range format

may cause a finite result to be

produced instead of an infinity. end example]