Why the output is false

Question

a = 0.1
b = 0.2
c = 0.3
print(a+b==c)

Answer 1

https://sololearn.com/compiler-playground/cUYHw2KG6Ws1/?ref=app

I believe its because your trying to use a base-10 system on a base-2 system (binary). You can only express fractions of a base by using its prime factors. The prime fractors of 10 are 2 and 5. So fractions like 1/2, 1/4, 1/8, 1/10,…. these numbers will result in a nice rounded number. If you were to do numbers whose fractions were 1/3,1/6,1/9, then you will get repeated numbers.

Computers use binary, so they use a base-2 system. The prime fractors for 2 is…2. So only fractions like 1/2,1/4,1/8 result in nice clean numbers. 1/5 and 1/10 are repeated because there prime factor is 5.

For repeated numbers, computers can’t write an infinite amount of something so the numbers are rounded off.

https://0.30000000000000004.com

Answer 2

Rahul Bankar ,

in many cases this issue does not matter if it is possible to do rounding.

however there are reasons that the precission matters. in this case we can use a different numerical data format `decimals`. (decimal module is shipped with the python installation):

https://sololearn.com/compiler-playground/c2CXgHef0K0G/?ref=app

Answer 3

Brian ,

it is not just fun to read all of these comments and figure out what is true or what is an assumption 🤣

Answer 4

Because it's in float value the calculation internally will change value in decimal terms with the c value which is leading to false as the answer. Hence you can use round function to round to 1 to get true as answer

Example a = round(value, roundoff_value)

Answer 5

Rahul Bankar
You can actually go this route and produce True as

import decimal from Decimals

x = 0.1 + 0.2
print(Decimal(float("%.1f"%x)) == .3)
#Converts the string of x to a float Decimal Ans = True
print(Decimal("%.1f"% x))
#.0.3

Answer 6

Operations on floats are an approximation. There's only so many bits available to represent a large amount of decimals in numbers. a + b is off by a very small amount.

This is why you should never compare two floats with ==. Instead you could take their absolute difference and check if it is less than a very small number (e.g., epsilon); if you wish to compare equality of two floats.

Answer 7

# Hi Rahul Bankar,

# Due to rounding errors in floating-point calculations,
# use isclose from the math module instead of ==.

from math import isclose
print(isclose(0.1 + 0.2, 0.3)) # Gives: True

# Alternatively, as previously mentioned, you can use the
# decimal module for higher precision.

Answer 8

Rahul Bankar here is similar code with explanation in the comments:

https://sololearn.com/compiler-playground/cda62498xsW9/?ref=app

Answer 9

or you can use math.isclose()

https://www.geeksforgeeks.org/JUMP_LINK__&&__python__&&__JUMP_LINK-math-library-isclose-method/

Answer 10

Bilal Mughal please do not spam in the comments and stay on topic.
Welcome to Sololearn
https://www.sololearn.com/discuss/1316935/?ref=app
https://www.sololearn.com/discuss/3021159/?ref=app

Answer 11

tolerance = 1e-10
print(abs((a + b) - c) < tolerance)

This will correctly evaluate whether the numbers are "close enough" to be considered equal.

Answer 12

Python's Standard Library contains a decimal module, which enables the problem to be avoided,

However, it needs to be imported and it has some cautions, see https://docs.python.org/3/library/decimal.html

Answer 13

Because, When you add 0.1 and 0.2, the result is not exactly 0.3 but rather a value very close to it (around 0.30000000000000004). This tiny difference arises from the limitations of floating-point arithmetic.

This is correct,
import math
a = 0.1
b = 0.2
c = 0.3
print(math.isclose(a+b,c))

Answer 14

Isn't 0.1+0.2 = 0.3

🤔🤔

Answer 15

The output is false because of how floating-point numbers are represented in computer memory. The numbers 0.1, 0.2, and 0.3 cannot be precisely represented in binary, leading to small rounding errors.

In Python, when you perform a + b, the result is slightly less than 0.3 due to this representation issue. Therefore, a + b == c evaluates to false.

To check for equality of floating-point numbers, it’s better to use a tolerance value

Answer 16

because it’s all these links

Answer 17

def diagnose_monkeypox(fever, rash, swollen_lymph_nodes, muscle_aches_fatigue, recent_travel):
score = 0

if fever > 38: # 38 degrees Celsius is equivalent to 100.4 Fahrenheit
score += 1

if rash == "face_and_spread":
score += 2

if swollen_lymph_nodes:
score += 1

if muscle_aches_fatigue:
score += 1

if recent_travel:
score += 2

return score

def main():
print("Welcome to the Monkeypox Diagnosis Consultation")
print("Please provide the following information about the patient:")

while True:
try:
fever = float(input("Enter the patient's temperature in Celsius: "))
break # Exit the loop if the input is valid
except ValueError:
print("Invalid input. Please enter a valid number.")

rash = input("Does the patient have a rash that started on the face and spread? (yes/no): ")
swollen_lymph_nodes = input("Does the patient have swollen lymph nodes?

Answer 18

Ec-101 we are not talking about error level or set the error level to minimum when calculating. This about the rules or python basic rule in maneging various datatypes

Answer 19

The output of the expression a + b == c being False is due to the way floating-point numbers are represented in computer memory, which can lead to precision issues.
1) Explanation
Floating-Point Representation:
In Python (and most programming languages), floating-point numbers are represented using a fixed number of binary digits. As a result, many decimal fractions cannot be represented precisely. For example, 0.1 and 0.2 have finite binary representations, but 0.3 does not.
2) Precision Error:
When you perform the operation a + b, the result is very close to 0.3, but not exactly 0.3. Instead, the result might be something like 0.30000000000000004.
3) Comparison Issue:
When you compare 0.30000000000000004 with 0.3, they are not equal, hence the output is False.

Answer 20

floating-point numbers are represented in a binary format that can't always precisely represent decimal values. Some numbers, like 0.1, 0.2, and 0.3, can't be represented exactly in binary, so when you perform arithmetic operations with them, small rounding errors can occur.

In this case:

a = 0.1 is stored as something like 0.10000000000000000555
b = 0.2 is stored as something like 0.20000000000000001110
a + b results in a value slightly different from 0.3. Specifically, it might be something like 0.30000000000000004, which is not exactly equal to 0.3 (which is internally represented as 0.29999999999999998889).
Since these values are not exactly the same, the result is False.