3228: Day Counter - Revision history

BunsenH: /* Explanation */ years will pass as days

2026-04-03T18:01:38Z

‎Explanation: years will pass as days

130.76.187.33: /* Transcript */ cats

2026-04-03T17:13:58Z

‎Transcript: cats

GSLikesCats307 at 17:10, 3 April 2026

2026-04-03T17:10:55Z

Scs: /* Explanation */

2026-04-03T15:44:59Z

‎Explanation

Scs: /* Explanation */ rm explicit parentheses that I added unnecessarily. also change some - to −

2026-04-03T15:36:11Z

‎Explanation: rm explicit parentheses that I added unnecessarily. also change some - to −

Scs: /* Explanation */

2026-04-03T15:08:08Z

‎Explanation

GSLikesCats307 at 14:58, 3 April 2026

2026-04-03T14:58:20Z

Scs: /* Explanation */ downplay "problem"

2026-04-03T14:55:33Z

‎Explanation: downplay "problem"

Scs: /* Explanation */

2026-04-03T14:40:39Z

‎Explanation

Scs: /* Explanation */ Stack Overflow link

2026-04-03T14:35:18Z

‎Explanation: Stack Overflow link

@@ Line 37: / Line 37: @@
 Coincidentally enough, [[Cueball]] is also floating — off his seat in this case. The seat itself looks the same as the chair in [[2144]], possibly meaning making people levitate is one of its numerous settings.
-Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it typically "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>−1 (2,147,483,647) to −2<sup>31</sup> (−2,147,483,648).
+Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it typically "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>−1 (2,147,483,647) to −2<sup>31</sup> (−2,147,483,648). 2,147,483,647 days from the comic's date of publication (April 3<sup>rd</sup>, 2026) is approximately October 12<sup>th</sup> of the year 5,881,636, assuming no changes in the lengths of the day and year, or in other aspects of time measurement.
 Strangely enough, when the comic was first published the sign number was −0.00000000000000017 days. It was changed later though, for unknown reasons.

← Older revision		Revision as of 17:13, 3 April 2026
Line 49:		Line 49:

	{{comic discussion}}<noinclude>[[Category:Interactive comics]][[Category:Dynamic comics]]		{{comic discussion}}<noinclude>[[Category:Interactive comics]][[Category:Dynamic comics]]
		+	[[Category:Programming]]
		+	[[Category:Math]]
		+	[[Category:Comics featuring White Hat]]
		+	[[Category:Comics featuring Ponytail]]
		+	[[Category:Comics featuring Cueball]]
		+	[[Category:Comics featuring Megan]]

@@ Line 39: / Line 39: @@
 Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it typically "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>−1 (2,147,483,647) to −2<sup>31</sup> (−2,147,483,648).
-Strangely enough, when the comic was first published the sign number was −0.00000000000000017 days.
+Strangely enough, when the comic was first published the sign number was −0.00000000000000017 days. It was changed later though, for unknown reasons.
 ==Transcript==

@@ Line 17: / Line 17: @@
 In this comic, a similar sign highlights the number of days since the last floating-point error.  Floating-point errors occur because most computers can devote only a finite amount of storage for each {{w|Floating-point arithmetic|floating point number}} or other fraction.  However, many {{w|real numbers}} and {{w|rational numbers}} theoretically require an infinite number of digits to represent them.  For example, the ordinary fraction ⅓ is represented in decimal as 0.3333333333…, where the 3's repeat forever.  When a number is truncated to fit in the finite amount of space, precision is inevitably lost, resulting in a slight roundoff error.  Unless carefully controlled, these roundoff errors can accumulate, significantly degrading the accuracy of floating-point computations.  For example, although ⅓ + ⅓ + ⅓ should obviously equal 1, a finite-precision calculation like 0.333 + 0.333 + 0.333 might show a misleading result of 0.999.
-This issue is exacerbated on computers which use binary arithmetic (i.e., virtually all computers today), since in binary, the ordinary fraction 1/10 is represented as the infinitely-repeating base-2 fraction <tt>0.00011001100110011011</tt>….  A classic example is that, depending on circumstances, the calculation 0.1 + 0.2 might [https://stackoverflow.com/questions/588004/is-floating-point-math-broken seem to give an answer of 0.30000001].
+This issue is exacerbated on computers which use binary arithmetic (i.e., virtually all computers today), since in binary, the ordinary fraction 1/10 is represented as the infinitely-repeating base-2 fraction <tt>0.000110011001100110011</tt>….  A classic example is that, depending on circumstances, the calculation 0.1 + 0.2 might [https://stackoverflow.com/questions/588004/is-floating-point-math-broken seem to give an answer of 0.30000001].
 Evidently, in the programming facility shown in the comic, a floating-point error has occurred today, and an attempt has been made to update the sign to say "It has been 0 days since...".  But the number 0 is displayed incorrectly, as the very small negative number −0.00000000000000044.  Perhaps the error that was made today was the very error that occurred in updating the sign!  (This would of course violate {{w|causality}}, but in comedy, self-referential humor beats causality every time.)

@@ Line 33: / Line 33: @@
 The program starts with the number 19, and subtracts 1.9 from it, ten times.  Mathematically, we would expect the result to be 0.  However, the number 1.9 cannot be represented exactly in binary, nor can the intermediate results 17.1, 15.2, 13.3, etc.  The cascading roundoff errors conspire to produce a result of −0.00000000000000044 instead of the expected 0.
-In the comic, such an error creates the ridiculous illusion that -0.00000000000000044 days have passed, which implies a 'negative' number of days, which is impossible{{cn}}. It also, even if it was a positive number, would mean that much less than a nanosecond had passed since the last error, which would be an unfeasably short amount of time. Of course, the joke is that in making the sign showing the amount of time since a floating point error was last made, they are creating a floating point error, meaning the sign is invalid. Also, if they tried to reset the sign, they might make the same error again, repeating the cycle over & over, which would not be ideal.
+In the comic, such an error creates the ridiculous illusion that −0.00000000000000044 days have passed, which implies a 'negative' number of days, which is impossible{{cn}}. It also, even if it was a positive number, would mean that much less than a nanosecond had passed since the last error, which would be an unfeasably short amount of time. Of course, the joke is that in making the sign showing the amount of time since a floating point error was last made, they are creating a floating point error, meaning the sign is invalid. Also, if they tried to reset the sign, they might make the same error again, repeating the cycle over & over, which would not be ideal.
-Coincidentally enough, [[Cueball]] is also floating - off his seat in this case. The seat itself looks the same as the chair in [[2144]], possibly meaning making people levitate is one of its numerous settings.
+Coincidentally enough, [[Cueball]] is also floating — off his seat in this case. The seat itself looks the same as the chair in [[2144]], possibly meaning making people levitate is one of its numerous settings.
-Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>-1 (2,147,483,647) to -(2<sup>31</sup>) (−2,147,483,648).
+Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it typically "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>−1 (2,147,483,647) to −2<sup>31</sup> (−2,147,483,648).
-Strangely enough, when the comic was first published the sign number was -0.00000000000000017 days.
+Strangely enough, when the comic was first published the sign number was −0.00000000000000017 days.
 ==Transcript==

← Older revision		Revision as of 14:58, 3 April 2026
Line 38:		Line 38:

	Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value gets bigger than the biggest integer that can be represented in a certain format, it "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>-1 (2,147,483,647) to -(2<sup>31</sup>) (−2,147,483,648).		Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value gets bigger than the biggest integer that can be represented in a certain format, it "wraps around" to the smallest value. In case of 32-bit signed integers it may wrap from 2<sup>31</sup>-1 (2,147,483,647) to -(2<sup>31</sup>) (−2,147,483,648).
		+
		+	Strangely enough, when the comic was first published the sign number was -0.00000000000000017 days.

	==Transcript==		==Transcript==

@@ Line 21: / Line 21: @@
 Evidently, in the programming facility shown in the comic, a floating-point error has occurred today, and an attempt has been made to update the sign to say "It has been 0 days since...".  But the number 0 is displayed incorrectly, as the very small negative number -0.00000000000000044.  Perhaps the error that was made today was the very error that occurred in updating the sign!  (This would of course violate {{w|causality}}, but in comedy, self-referential humor beats causality every time.)
-As an example of how the number -0.00000000000000044 could have arisen when 0 was intended, consider this simple {{w|C (programming language)|C}} program:
+As an example of how the number −0.00000000000000044 could have arisen when 0 was intended, consider this simple {{w|C (programming language)|C}} program:
   #include <stdio.h>
@@ Line 31: / Line 31: @@
+  }
-The program starts with the number 19, and subtracts 1.9 from it, ten times.  Mathematically, we would expect the result to be 0.  However, the number 1.9 cannot be represented exactly in binary, nor can the intermediate results 17.1, 15.2, 13.3, etc.  The cascading roundoff errors conspire to produce a result slightly less than 0.
+The program starts with the number 19, and subtracts 1.9 from it, ten times.  Mathematically, we would expect the result to be 0.  However, the number 1.9 cannot be represented exactly in binary, nor can the intermediate results 17.1, 15.2, 13.3, etc.  The cascading roundoff errors conspire to produce a result of −0.00000000000000044 instead of the expected 0.
 This creates the ridiculous illusion that -0.00000000000000044 days have passed, which implies a 'negative' number of days, which is impossible{{cn}}. It also, even if it was a positive number, would mean that much less than a nanosecond had passed since the last error, which would be an unfeasably short amount of time. Of course, the joke is that in making the sign showing the amount of time since a floating point error was last made, they are creating a floating point error, meaning the sign is invalid. Also, if they tried to reset the sign, they might make the same error again, repeating the cycle over & over, which would not be ideal.

@@ Line 17: / Line 17: @@
 In this comic, a similar sign highlights the number of days since the last floating-point error.  Floating-point errors occur because most computers can devote only a finite amount of storage for each {{w|Floating-point arithmetic|floating point number}} or other fraction.  However, many {{w|real numbers}} and {{w|rational numbers}} theoretically require an infinite number of digits to represent them.  For example, the ordinary fraction ⅓ is represented in decimal as 0.3333333333…, where the 3's repeat forever.  When a number is truncated to fit in the finite amount of space, precision is inevitably lost, resulting in a slight roundoff error.  Unless carefully controlled, these roundoff errors can accumulate, seriously degrading the accuracy of floating-point computations.  For example, although ⅓ + ⅓ + ⅓ should obviously equal 1, a finite-precision calculation like 0.333 + 0.333 + 0.333 might show a misleading result of 0.999.
-This problem is exacerbated on computers which use binary arithmetic (i.e., virtually all computers today), since in binary, the ordinary fraction 1/10 is represented as the infinitely-repeating binary fraction <tt>0.00011001100110011011</tt>….  A classic example of the problem is that, depending on circumstances, the calculation 0.1 + 0.2 might seem to give an answer of 0.30000001.
+This problem is exacerbated on computers which use binary arithmetic (i.e., virtually all computers today), since in binary, the ordinary fraction 1/10 is represented as the infinitely-repeating binary fraction <tt>0.00011001100110011011</tt>….  A classic example of the problem is that, depending on circumstances, the calculation 0.1 + 0.2 might [https://stackoverflow.com/questions/588004/is-floating-point-math-broken seem to give an answer of 0.30000001].
 Evidently, in the programming facility shown in the comic, a floating-point error has occurred today, and an attempt has been made to update the sign to say "It has been 0 days since...".  But the number 0 is displayed incorrectly, as the very small negative number -0.00000000000000044.  Perhaps the error that was made today was the very error that occurred in updating the sign!  (This would of course violate {{w|causality}}, but in comedy, self-referential humor beats causality every time.)
@@ Line 35: / Line 35: @@
 This creates the ridiculous illusion that -0.00000000000000044 days have passed, which implies a 'negative' number of days, which is impossible{{cn}}. It also, even if it was a positive number, would mean that much less than a nanosecond had passed since the last error, which would be an unfeasably short amount of time. Of course, the joke is that in making the sign showing the amount of time since a floating point error was last made, they are creating a floating point error, meaning the sign is invalid. Also, if they tried to reset the sign, they might make the same error again, repeating the cycle over & over, which would not be ideal.
-Coincidentally enough, [[Cueball]] is also floating - off his seat in this case. The seat itself looks the same as the chair in [[2144]], possibly meaning making people levitate is one of it's numerous settings.
+Coincidentally enough, [[Cueball]] is also floating - off his seat in this case. The seat itself looks the same as the chair in [[2144]], possibly meaning making people levitate is one of its numerous settings.
 Floating point errors are particularly common in programming, especially in languages that implicitly convert decimal numbers to binary floating point, so an approximation is already made at conversion leading to unexpected results. The title text cites another common programming problem, integer overflow. When a value  gets bigger than the biggest integer that can be represented in a certain format, it "wraps around" to the smallest value. In case of 32-bit signed integers it wraps from 2<sup>31</sup>-1 (2,147,483,647) to -2<sup>31</sup> (−2,147,483,648).