Floating point arithmetic

Introduction:

In the world of computer science, floating-point arithmetic (FP) plays a crucial role in performing calculations with real numbers. By using a formulaic representation, floating-point arithmetic allows for a balance between range and precision. This article will delve into the intricacies of floating-point arithmetic, exploring its representation, precision, and the trade-offs involved. Additionally, we will provide code examples in popular programming languages such as C#, JavaScript, Python, and PHP.

Understanding Floating-Point Arithmetic:

Floating-point arithmetic is designed to handle a wide range of real numbers, including both very small and very large values. This is accomplished by representing numbers approximately using a fixed number of significant digits (significand) and scaling them using an exponent in a fixed base. The most commonly used bases for scaling are two, ten, or sixteen.

Representation of Floating-Point Numbers:

A floating-point number is represented in the following form: significand × base exponent. The significand is the approximation of the number, while the base represents the scaling factor, and the exponent determines the magnitude. By adjusting the significand and exponent, floating-point arithmetic achieves a flexible representation of real numbers.

Precision and Accuracy:

One of the key considerations in floating-point arithmetic is precision. Due to the nature of approximation, floating-point numbers cannot always represent every real number exactly. Instead, they provide an approximation within a certain precision range. The precision is determined by the number of significant digits used to represent the number.
For example, consider the following code snippet in C#:

Output: 11.11111
In this example, the result of adding a and b is not exactly 11.11111, but rather an approximation within the precision range of the floating-point representation.

Trade-Offs in Floating-Point Arithmetic:

Floating-point arithmetic involves trade-offs between range and precision. By using a fixed number of significant digits, the representation can accommodate a wide range of numbers. However, this comes at the cost of reduced precision, as the available digits must be shared across the entire range.

Consider the following Python code snippet:

Output: 12.178478135052443
In this example, the multiplication of x and y results in an approximation due to the limited precision. While the overall range is preserved, the precision is compromised.

Links

Code Examples

C#
float a = 1.23456789f;
float b = 9.87654321f;
float result = a + b;

Console.WriteLine(result);

JavaScript
let x = 5.67;
let y = 8.91;
let result = x - y;

console.log(result);

Python
x = 1.23456789
y = 9.87654321
result = x * y

print(result)

PHP
$x = 7.89;
$y = 1.23;
$result = $x * $y;

echo $result;

Conclusion