Floating-point arithmetic is considerably more involved and computationally intensive than integer arithmetic. This is due to the separate exponent and mantissa components, the need for alignment, normalization, and precise rounding. These operations are typically handled by a dedicated hardware unit called the Floating-Point Unit (FPU), which may be integrated into the main CPU or exist as a separate co-processor.

These are the most complex floating-point operations. 1. Extract Components: The sign, exponent, and mantissa are extracted from both operands. 2. Handle Special Cases: Check for operands being zero, infinity, or NaN. If any are present, special rules apply (e.g., X+infty=infty). 3. Align Exponents: For addition/subtraction, the exponents must be the same. The mantissa of the number with the smaller exponent is shifted right until its exponent matches the larger exponent. Each right shift of the mantissa effectively divides the number by 2, and incrementing the exponent multiplies it by 2, maintaining the number's value. This process ensures the binary points are aligned before addition/subtraction. 4. Add/Subtract Mantissas: Once exponents are aligned, the mantissas are added or subtracted as if they were integers (using an integer adder/subtractor). The sign of the result is determined. 5. Normalize Result: The result of the mantissa operation might not be normalized (e.g., it might be 0.xxxx_2 if it underflowed, or 10.xxxx_2 if it overflowed during addition). The mantissa is then shifted left or right, and the exponent is adjusted accordingly, until the mantissa is in the 1.xxxx_2 normalized form. 6. Round Result: After normalization, the result's mantissa may have more bits than the target format (e.g., 23 bits for single-precision). The mantissa must be rounded to fit the available precision according to the chosen rounding mode. 7. Check for Over/Underflow: After rounding and final normalization, the exponent is checked to ensure it falls within the representable range. If it's too large, the result becomes pminfty. If it's too small, it might become a denormalized number or pm0.0.

These operations are generally simpler than addition/subtraction because exponent alignment is not required in the same way. 1. Extract Components: Separate sign, exponent, and mantissa. 2. Handle Special Cases: Check for zeros, infinities, NaNs. 3. Multiply/Divide Signs: The sign of the result is determined by XORing the sign bits of the two operands. (Same signs rightarrow positive (0); Different signs rightarrow negative (1)). 4. Add/Subtract Exponents: For Multiplication: The true exponents are added. To account for the bias, the formula is usually: Result_Exponent_Biased = (Exp1_Biased + Exp2_Biased) - Bias. For Division: The true exponents are subtracted. The formula is usually: Result_Exponent_Biased = (Exp1_Biased - Exp2_Biased) + Bias. 5. Multiply/Divide Mantissas: The mantissas are multiplied or divided as if they were unsigned integers. This typically produces a mantissa result with double the precision of the input mantissas (e.g., 24-bit * 24-bit multiplication yields a 48-bit product). 6. Normalize Result: The resulting mantissa is normalized (shifted and exponent adjusted). 7. Round Result: The normalized mantissa is rounded to the target format's precision. 8. Check for Over/Underflow: Verify that the final exponent is within the valid range, otherwise set the result to pminfty, pm0.0, or a denormalized number.

The IEEE 754 standard specifies four primary rounding modes to manage the precision limitation when an exact result cannot be represented: 1. Round to Nearest Even (RoundTiesToEven): This is the default and most commonly used rounding mode. It rounds the result to the nearest representable floating-point number. If the exact result falls precisely halfway between two representable numbers, it rounds to the one whose least significant bit (LSB) of the mantissa is 0 (i.e., the "even" one). 2. Round to Zero (Chop/Truncate): This mode rounds the result towards zero. This means simply discarding (truncating) any bits beyond the specified precision. For positive numbers, it effectively rounds down; for negative numbers, it effectively rounds up towards zero. 3. Round to Plus Infinity (RoundUp): This mode rounds the result towards positive infinity. For any unrounded result, it rounds to the smallest representable floating-point number that is greater than or equal to the unrounded value. 4. Round to Minus Infinity (RoundDown): This mode rounds the result towards negative infinity. For any unrounded result, it rounds to the largest representable floating-point number that is less than or equal to the unrounded value.

While indispensable, floating-point arithmetic introduces inherent limitations that must be understood to avoid common pitfalls in numerical computation: 1. Finite Precision: Floating-point numbers represent a continuous range of real numbers using a finite number of bits. This means that only a discrete subset of real numbers can be represented exactly. Most real numbers, especially irrational numbers (like pi or sqrt2) or even simple decimal fractions that do not have a finite binary representation (like 0.1), cannot be stored precisely. They are instead approximated by the closest representable floating-point number. 2. Rounding Errors: Due to this finite precision, almost every arithmetic operation on floating-point numbers involves some degree of rounding. These small rounding errors, though tiny individually, can accumulate over a long sequence of computations. This accumulation can lead to a significant loss of accuracy in the final result, especially in iterative algorithms or when many operations are performed. 3. Loss of Significance (Catastrophic Cancellation): A particularly problematic form of rounding error occurs when two floating-point numbers of nearly equal magnitude are subtracted. The most significant bits, which are identical, cancel each other out, leaving a result with far fewer significant digits. The remaining bits (the less significant ones) may then largely consist of accumulated rounding errors from prior operations, leading to a drastically reduced effective precision and a highly inaccurate result. 4. Non-Associativity of Addition/Multiplication: Unlike true real number arithmetic, floating-point arithmetic is not always strictly associative. This means that (A+B)+C might not yield precisely the same result as A+(B+C) due to intermediate rounding. The order of operations can influence the final accuracy. 5. Limited Exact Integer Representation: While floating-point numbers can represent integers, they can only do so exactly up to a certain magnitude (e.g., up to 224 for single-precision, or 253 for double-precision). Beyond this range, integers also become subject to rounding when stored as floating-point numbers, as the gaps between representable floating-point numbers become larger than 1. 6. Special Values and Their Behavior: The existence of pminfty and NaN means that mathematical operations can produce non-numerical results. This necessitates careful handling in software to prevent these special values from propagating unexpectedly and invalidating further computations.