Why does C floating-point arithmetic produce unexpected results, and how can we mitigate these precision anomalies?

C Floating-Point Precision Anomaly and Resolution

Despite their widespread use, floating-point numbers in C exhibit limitations in precision. Consider the following code snippet:

<code class="cpp">double a = 0.3;
std::cout.precision(20);
std::cout <p>This code outputs 0.2999999999999999889 instead of the expected 0.3. This discrepancy occurs because the variable a is not stored exactly as a 0.3 double-precision floating-point number but rather an approximation of it due to the finite representation of floating-point values.</p>
<p>A more surprising behavior arises when a is repeatedly added 50 times:</p>
<pre class="brush:php;toolbar:false"><code class="cpp">double a, b;
a = 0.3;
b = 0;
for (char i = 1; i <p>This code surprisingly outputs 15.000000000000014211 instead of 15.0. This is because each addition accumulates the approximation error, leading to an accumulated error greater than the original precision.</p>
<p><strong>Resolving the Precision Anomaly</strong></p>
<p>To obtain precise results, it is crucial to avoid setting the output precision greater than the available digits for the numeric type. This can be achieved using the std::numeric_limits class:</p>
<pre class="brush:php;toolbar:false"><code class="cpp">#include <iostream>
#include <limits>
int main()
{
        double a = 0.3;
        std::cout.precision(std::numeric_limits<double>::digits10);
        std::cout ::digits10);
        std::cout <p>This code uses the digits10 member function to set the precision to the maximum available digits for a double-precision floating-point number, which is 15 digits for double.</p>
<p><strong>Limitations of Floating-Point Arithmetic</strong></p>
<p>While the provided solution minimizes the precision error, it is important to recognize that floating-point arithmetic has inherent limitations. If a loop involves thousands of iterations, even with the precision set appropriately, the accumulated error may become significant. In such scenarios, alternative data types, such as fixed-point numbers or rational numbers, may be more suitable for maintaining exact values.</p></double></limits></iostream></code>

The above is the detailed content of Why does C floating-point arithmetic produce unexpected results, and how can we mitigate these precision anomalies?. For more information, please follow other related articles on the PHP Chinese website!