+ 6

Why the output is false

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

21st Sep 2024, 7:29 PM
Rahul Bankar
Rahul Bankar - avatar
30 ответов
+ 11
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
21st Sep 2024, 8:25 PM
Junior
Junior - avatar
+ 9
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
21st Sep 2024, 8:06 PM
Lothar
Lothar - avatar
+ 5
Brian , it is not just fun to read all of these comments and figure out what is true or what is an assumption 🤣
21st Sep 2024, 8:18 PM
Lothar
Lothar - avatar
+ 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)
21st Sep 2024, 7:54 PM
Aysha
Aysha - avatar
+ 4
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
22nd Sep 2024, 1:19 AM
BroFar
BroFar - avatar
+ 4
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.
22nd Sep 2024, 2:40 AM
Rrestoring faith
Rrestoring faith - avatar
+ 4
# 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.
22nd Sep 2024, 9:27 PM
Per Bratthammar
Per Bratthammar - avatar
+ 3
Rahul Bankar here is similar code with explanation in the comments: https://sololearn.com/compiler-playground/cda62498xsW9/?ref=app
21st Sep 2024, 8:03 PM
Brian
Brian - avatar
+ 3
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
11th Oct 2024, 7:13 PM
BroFar
BroFar - avatar
+ 2
tolerance = 1e-10 print(abs((a + b) - c) < tolerance) This will correctly evaluate whether the numbers are "close enough" to be considered equal.
22nd Sep 2024, 8:31 AM
EC-101
EC-101 - avatar
+ 2
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
24th Sep 2024, 5:11 AM
Jonathan Shiell
+ 2
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))
30th Sep 2024, 8:39 AM
Pasindu Randula
Pasindu Randula - avatar
+ 1
Isn't 0.1+0.2 = 0.3 🤔🤔
21st Sep 2024, 7:35 PM
Rahul Bankar
Rahul Bankar - avatar
+ 1
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
22nd Sep 2024, 8:29 AM
EC-101
EC-101 - avatar
+ 1
because it’s all these links
23rd Sep 2024, 12:18 PM
Ilya
Ilya - avatar
+ 1
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?
23rd Sep 2024, 1:14 PM
April Lean Aquino
April Lean Aquino - avatar
+ 1
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
24th Sep 2024, 5:04 AM
Oliver Pasaribu
+ 1
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.
9th Oct 2024, 11:35 AM
Aramayis Hayrapetyan
+ 1
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.
9th Oct 2024, 4:49 PM
Al-hosseiny Hassan
Al-hosseiny Hassan - avatar