--- title: "Why 0.1 + 0.2 != 0.3 in Programming and How to Fix It" description: "Learn why 0.1 + 0.2 != 0.3 in programming, understand floating-point arithmetic issues, and discover solutions for precise decimal calculations." slug: "why-01-02-03-in-programming-and-how-to-fix-it" url: "https://furkanbaytekin.dev/blogs/why-01-02-03-in-programming-and-how-to-fix-it" author: "Furkan Baytekin" category: "Software" tags: [] published: 2025-05-29T08:23:39Z updated: 2025-05-29T08:23:39Z readTime: 6 cover: "https://myblogcms.furkanbaytekin.dev/uploads/cover/why-01-02-03-in-programming-and-how-to-fix-it+1748122734237" --- If you've ever written code and noticed that `0.1 + 0.2` doesn't equal `0.3`, you're not alone. This surprising behavior occurs in many programming languages due to the way computers handle floating-point numbers. In this article, we'll explore why this happens, how it manifests in popular languages like JavaScript, Python, C, Rust, Go, Java, C#, and PHP, and how to work around it. We'll also highlight languages and tools that provide precise decimal arithmetic. ## Understanding the IEEE 754 Standard Most modern programming languages use the **IEEE 754 standard** for floating-point arithmetic. This standard represents numbers in a binary format, which is great for performance but problematic for certain decimal fractions. Numbers like `0.1` and `0.2` cannot be represented exactly in binary, leading to tiny rounding errors. When you add `0.1 + 0.2`, the result is a number like `0.30000000000000004` instead of the expected `0.3`. This issue arises because IEEE 754 uses a finite number of bits to approximate decimal fractions, much like how `1/3` cannot be precisely represented as a decimal (0.333...). Let's see how this plays out in different programming languages. ## The Issue in Popular Programming Languages ### JavaScript In JavaScript, floating-point numbers follow IEEE 754 double-precision. Try this in a JavaScript console: ```javascript console.log(0.1 + 0.2); // Output: 0.30000000000000004 ``` The result is not exactly `0.3` due to the binary approximation of `0.1` and `0.2`. **Solution**: Use fixed-point arithmetic with `toFixed()` for display or libraries like [Decimal.js](https://mikemcl.github.io/decimal.js/) for precise calculations. ```javascript // Using toFixed for display console.log((0.1 + 0.2).toFixed(1)); // Output: "0.3" // Using Decimal.js const Decimal = require('decimal.js'); console.log(Decimal(0.1).plus(0.2).toString()); // Output: "0.3" ``` ### Python Python also uses IEEE 754 double-precision floats. Running this code: ```python print(0.1 + 0.2) # Output: 0.30000000000000004 ``` shows the same issue. **Solution**: Python's `decimal` module provides precise decimal arithmetic. ```python from decimal import Decimal print(Decimal('0.1') + Decimal('0.2')) # Output: 0.3 ``` Use string inputs (`'0.1'`) to avoid floating-point errors when initializing `Decimal` objects. ### C In C, floating-point numbers are typically IEEE 754. Here's an example: ```c #include int main() { double a = 0.1; double b = 0.2; printf("%.17f\n", a + b); // Output: 0.30000000000000004 return 0; } ``` **Solution**: C doesn't have a built-in decimal type, but you can use libraries like [GMP](https://gmplib.org/) for arbitrary-precision arithmetic or implement fixed-point arithmetic manually. ### Rust Rust uses IEEE 754 for its `f64` type: ```rust fn main() { let sum = 0.1 + 0.2; println!("{:.17}", sum); // Output: 0.30000000000000004 } ``` **Solution**: Use the `rust-decimal` crate for decimal arithmetic. ```rust use rust_decimal::Decimal; fn main() { let a = Decimal::from_str("0.1").unwrap(); let b = Decimal::from_str("0.2").unwrap(); println!("{}", a + b); // Output: 0.3 } ``` ### Go Go's floating-point numbers are IEEE 754-compliant: ```go package main import "fmt" func main() { fmt.Printf("%.17f\n", 0.1+0.2) // Output: 0.30000000000000004 } ``` **Solution**: Go doesn't have a standard decimal library, but you can use third-party packages like `shopspring/decimal`: ```go package main import ( "fmt" "github.com/shopspring/decimal" ) func main() { a := decimal.NewFromFloat(0.1) b := decimal.NewFromFloat(0.2) fmt.Println(a.Add(b)) // Output: 0.3 } ``` ### Java Java uses IEEE 754 for `double` and `float`: ```java public class Main { public static void main(String[] args) { System.out.printf("%.17f\n", 0.1 + 0.2); // Output: 0.30000000000000004 } } ``` **Solution**: Use `BigDecimal` for precise decimal arithmetic. ```java import java.math.BigDecimal; public class Main { public static void main(String[] args) { BigDecimal a = new BigDecimal("0.1"); BigDecimal b = new BigDecimal("0.2"); System.out.println(a.add(b)); // Output: 0.3 } } ``` ### C# C# also follows IEEE 754: ```csharp using System; class Program { static void Main() { Console.WriteLine(0.1 + 0.2); // Output: 0.30000000000000004 } } ``` **Solution**: Use the `decimal` type for precise calculations. ```csharp using System; class Program { static void Main() { decimal a = 0.1m; decimal b = 0.2m; Console.WriteLine(a + b); // Output: 0.3 } } ``` ### PHP PHP uses IEEE 754 for floating-point numbers: ```php ``` **Solution**: Use the `bcmath` extension for arbitrary-precision arithmetic. ```php ``` ## Languages with Precise Decimal Arithmetic Some languages avoid this issue by default or provide built-in solutions for precise decimal arithmetic: - **Python's `decimal` module**: As shown, it handles decimal numbers accurately when initialized with strings. - **C#'s `decimal` type**: Designed for financial calculations, it avoids IEEE 754 pitfalls. - **Java's `BigDecimal`**: Offers precise decimal arithmetic for financial and scientific applications. - **Ruby**: The `BigDecimal` class in Ruby's standard library provides similar precision. ```ruby require 'bigdecimal' puts (BigDecimal("0.1") + BigDecimal("0.2")).to_s # Output: 0.3 ``` - **Libraries in Other Languages**: Libraries like `Decimal.js` (JavaScript), `rust-decimal` (Rust), and `shopspring/decimal` (Go) provide decimal arithmetic where the standard library doesn't. ## How to Prevent Floating-Point Errors Here are general strategies to avoid floating-point issues: 1. **Use Decimal Libraries**: Libraries like `decimal` (Python), `BigDecimal` (Java), or `decimal` (C#) are designed for precise arithmetic. 2. **Fixed-Point Arithmetic**: Multiply numbers by a power of 10, perform integer arithmetic, and divide back. For example, to add `0.1` and `0.2`, multiply by 100, add `10 + 20 = 30`, then divide by 100 to get `0.3`. 3. **Rounding for Display**: Use functions like `toFixed()` (JavaScript) or `printf` with limited precision to mask small errors in output. 4. **String-Based Inputs**: When using decimal libraries, initialize numbers as strings (e.g., `Decimal('0.1')` in Python) to avoid initial floating-point errors. 5. **Avoid Equality Checks**: Instead of `if (0.1 + 0.2 == 0.3)`, use a tolerance check like `Math.abs((0.1 + 0.2) - 0.3) < 0.0000001`. ## Why It Matters Floating-point errors can lead to significant issues in financial applications, scientific computations, or any domain requiring high precision. Understanding these quirks helps you write robust code and choose the right tools for your needs. ## Conclusion The `0.1 + 0.2 != 0.3` issue is a common pitfall in languages using IEEE 754, including JavaScript, Python, C, Rust, Go, Java, C#, and PHP. By using decimal libraries, fixed-point arithmetic, or careful rounding, you can avoid these errors. Languages like Python, C#, and Java offer built-in solutions for precise decimal arithmetic, while libraries like `Decimal.js` and `rust-decimal` fill the gap in others. Next time you encounter this issue, you'll know exactly how to handle it! --- Album of the day: