C Floating-Point Numbers

• Floating-point numbers are used to represent non-integer values in C.
• They are essential for scientific, engineering, and graphical applications requiring real numbers.
• C provides three floating-point data types: float, double, and long double.

Floating-Point Data Types

• float is typically a single-precision floating-point type, usually represented using 32 bits.
• double is a double-precision floating-point type, commonly represented using 64 bits.
• long double is an extended-precision floating-point type, which may use 80, 96, or 128 bits, depending on the compiler and platform.
• Precision and range increase from float to double to long double.

IEEE 754 Standard

• Most C implementations use the IEEE 754 standard for representing floating-point numbers.
• This standard defines how floating-point numbers are stored, including the representation of special values like infinity and NaN (Not a Number).
• It specifies the format for the sign, exponent, and mantissa (also called significand or fraction).

Representation of Floating-Point Numbers

• A floating-point number is represented in the form: (-1)^sign * mantissa * 2^exponent.
• The sign bit indicates whether the number is positive or negative.
• The mantissa represents the significant digits of the number.
• The exponent determines the scale or magnitude of the number.

Format for float (32-bit)

• Sign bit: 1 bit
• Exponent: 8 bits
• Mantissa: 23 bits

Format for double (64-bit)

• Sign bit: 1 bit
• Exponent: 11 bits
• Mantissa: 52 bits

Normalization

• Floating-point numbers are typically stored in normalized form.
• Normalization means adjusting the mantissa and exponent so that the mantissa has a leading non-zero digit.
• For binary floating-point numbers, the mantissa is normalized to have a leading '1' before the binary point (implicit leading bit).

Exponent Bias

• The exponent is stored with a bias to allow representation of both positive and negative exponents without using a sign bit.
• For float, the bias is 127. For double, the bias is 1023.
• The actual exponent is calculated by subtracting the bias from the stored exponent value.

Special Values

• Zero: Represented with a zero mantissa and a biased exponent of zero. Both +0 and -0 exist.
• Infinity: Represented with a maximum exponent and a zero mantissa (+infinity and -infinity).
• NaN: Represented with a maximum exponent and a non-zero mantissa.

Floating-Point Arithmetic

• Floating-point arithmetic operations can introduce rounding errors due to the limited precision.
• Addition, subtraction, multiplication, and division may not always produce exact results.
• Rounding modes (e.g., round to nearest, round towards zero) are used to handle these errors.

Common Issues

• Rounding Errors: Can accumulate over multiple operations.
• Comparison: Direct equality comparisons (==) can be problematic due to potential rounding errors. Use tolerance-based comparisons instead.
• Overflow/Underflow: Occurs when the result of an operation is too large or too small to be represented.

Floating-Point Literals

• Floating-point literals in C can be written with or without exponents.
• Examples: 3.14, 1.0e-5, 2.0f (for float), 3.0l (for long double).
• By default, floating-point literals are treated as double.

Standard Library Functions

• <math.h> provides functions for performing mathematical operations on floating-point numbers (e.g., sqrt, sin, cos, pow).
• <float.h> defines macros related to floating-point types, such as minimum and maximum representable values and precision.

Example

• Example of declaring and initializing floating-point variables:

    float myFloat = 3.14f;
    double myDouble = 3.14159265359;
    long double myLongDouble = 3.141592653589793238L;

Precision

• Precision refers to the number of significant digits that can be accurately represented.
• float typically provides about 7 decimal digits of precision.
• double typically provides about 15-17 decimal digits of precision.

Best Practices

• Use double as the default floating-point type unless memory is a significant constraint.
• Be cautious when comparing floating-point numbers for equality.
• Understand the limitations of floating-point arithmetic and potential sources of error.
• Use appropriate rounding techniques when necessary.
• Be aware of potential overflow and underflow conditions.

Converting Integers to Floating-Point

• When an integer is converted to a floating-point number, there may be a loss of precision if the integer is too large to be represented exactly by the floating-point type.

Converting Floating-Point to Integer

• When a floating-point number is converted to an integer, the fractional part is truncated (discarded). No rounding occurs.
• If the floating-point number is outside the range of the integer type, the behavior is undefined.

Compiler Optimizations

• Compilers may perform optimizations on floating-point expressions, which can sometimes lead to unexpected results due to changes in the order of operations.
• The volatile keyword can be used to prevent certain optimizations.

Floating Point Exceptions

• Floating-point exceptions, like division by zero or overflow, can occur during computations.
• The <fenv.h> header provides functions to manage floating-point exceptions, including checking and clearing exception flags.

Denormalized Numbers

• Denormalized (or subnormal) numbers are used to represent values closer to zero than the smallest normal number.
• They provide a way to gradually underflow, but with reduced precision.
• Not all hardware supports denormalized numbers, which can lead to performance issues.

Impact of Architecture

• Floating-point behavior can be influenced by the underlying hardware architecture, as different processors may implement the IEEE 754 standard with slight variations.
• Compiler settings can also affect how floating-point operations are handled.