erikwiffin/0.30000000000000004

Floating Point Math Examples

0.30000000000000004's Issues

add equality test

I would recommend adding another test that shows whether

0.1+0.2==0.3

in the various languages. One or two will get it right, but most do not, even the ones that print 0.3 when you do the addition.

The Hyperlink of Mathematica is Unavaliable now

https://reference.wolfram.com/language/tutorial/NumericalPrecision.html

The website shows "可以使用以上搜索栏查询整个网站，或者尝试以下链接。" in Chinese, which mean "You may use search bar or try the following link(s)."
Maybe you should replace or delete this hyperlink.

Redirect 30000000000000004.com

Hi there,
It would be good to redirect people who visited 30000000000000004.com to 0.30000000000000004.com

erlang examples

1> io:format("~f~n", [0.1 + 0.2]). 
0.300000
ok
2> io:format("~e~n", [0.1 + 0.2]).
3.00000e-1

objective-c gone

objective-c gone from the list of languages on website after updating examples.

Note on GHC

Using Double triggers the Problem in GHC, Float works fine (could be a precision reason, though):

Prelude> 0.2 + 0.1 :: Double
0.30000000000000004
Prelude> 0.2 + 0.1 :: Float 
0.3

Enforce HTTPS

Hi there, GitHub has an option to redirect the traffic from HTTP to HTTPS, it's in the project settings under the GitHub Pages section

Comparsion results

What do you think about adding column with result of 0.1+0.2==0.3 ?

The APL result is wrong

I will open a PR later.

C# has a decimal type

C# has a decimal type that handles the addition properly.

decimal correct = 0.1m + 0.2m;
Console.WriteLine(correct);

Output:
0.3

Example: https://dotnetfiddle.net/xcsQdh

Common Lisp does have this issue as well, when explicitly using double floats

Tested on both SBCL and ECL, (+ 0.1d0 0.2d0) does actually produce 0.30000000000000004d0.

Project description and link

The link at the end of the README could be added to the repository metadata fields at the top of the page, where it would be more accessible.

A description can also be added there, which would appear in the page title in browser tabs, in search results, etc.

python has a Decimal module

https://docs.python.org/library/decimal.html

Text overflow between columns on long code blocks.

At least in Firefox, the longer code blocks overflow into the next column, resulting in a messy layout.

Firefox screenshot (overflow):

Chrome screenshot (scrollbars):

Possibly adding the overflow property to the td elements would help?

Add GNU Octave Code and Results

The results are partially different with which in Matlab.

File:

---

layout: post
title: 'GNU Octave'
code:

• 0.1 + 0.2
• single(0.1)+single(0.2)
• double(0.1)+double(0.2)
• 0.1+single(0.2)
• 0.1+double(0.2)
• "sprintf('%.17f',0.1+0.2)"
  result:
• 0.30000
• 0.30000
• 0.30000
• 0.30000
• 0.30000
• 0.30000000000000004

---

Additionally, I met an error-403 while "git push". Could you give me the push permission?

Stylishcoins

Question: What Version of c#/.Net Framework?

On .Net 4.6, Console.Writeline(0.1 + 0.2); outputs 0.3

The PHP example wrongly suggests PHP acts properly

Your echo .1 + .2; displays 0.3 because PHP converts it to a string in echo first while still internally using 0.30000000000000004. You can verify this with: echo ceil((.1 + .2) * 10); (this prints 4). My suggestion is to run a similar test for all languages and displaying and (if needed) explaining the results.

Clojure improvements

;; Bigdecimal support
(+ 0.1M 0.2M)
; => 0.3

;; Ratios
(+ 1/10 2/10)
;=> 3/10

DAX example

There are not that many examples of this in Data Analysis Expressions (DAX),

It would be:

EVALUATE { VAR _sum = 0.1 + 0.2 // 0.30000000000000004 RETURN IF( _sum = 0.3, ":)", ":(" ) }

EVALUATE { VAR _sum = CURRENCY( 0.1 ) + CURRENCY( 0.2 ) // 0.3 RETURN IF( _sum = 0.3, ":)", ":(" ) }

decimal.js

In JavaScript, this library provides an “arbitrary-precision Decimal type” http://mikemcl.github.io/decimal.js/

Raku output is truncated

Although the markdown source for Raku shows the correct output to raku -e 'say (0.1 + 0.2).fmt("%.17f")' is 0.30000000000000000, on the published website just shows the output as 0.3.

Allowed to Mirror?

Hey Erik Wiffin. Thanks for your initiative to build this site. Very helpful to introduce people about floating point.

Yet, the main site: http://0.30000000000000004.com/ seems down right now so i can't refer people to this site. Currently, there is no way to access this website other than from GH repo and archive.is. Could i mirror this? I don't see LICENSE file so i ask about this.

Also related to #105

C++ has rational library

http://www.boost.org/doc/libs/1_61_0/libs/rational/rational.html

Some more database info

A bug I filed about IEEE 754 documentation a while ago for MySQL:
https://bugs.mysql.com/bug.php?id=57519

Support for NaN differs between MySQL and PostgreSQL. I didn't see any information about the 'special' values on http://0.30000000000000004.com

Note that there are different behaviors within one database system:
http://sqlfiddle.com/#!6/12e70/3

CREATE TABLE t1 (f FLOAT);
SELECT 0.1 + 0.2;
INSERT INTO t1 VALUES(0.1),(0.2);
SELECT SUM(f) FROM t1;

With Microsoft SQL Server 2014 this has the following output:

0.3
0.30000000000000004

With MySQL 5.6:

0.3
0.30000000447034836

http://sqlfiddle.com/#!9/2e75e/1

Oracle 11gR2 returns 0.3 in both cases:
http://sqlfiddle.com/#!4/0509e6/4

Note that Oracle has FLOAT and BINARY_FLOAT
http://sqlfiddle.com/#!4/cf223/1

awk example is deceptive

$ awk --version | head -1
GNU Awk 5.1.1, API: 3.1 (GNU MPFR 4.1.0-p13, GNU MP 6.2.1)

The example indeed prints 0.3, but 0.1 + 0.2 != 0.3:

$ awk 'BEGIN { print 0.1 + 0.2 }'
0.3
$ awk 'BEGIN { print (0.1 + 0.2) == 0.3 }'
0

It's because

$ awk 'BEGIN { printf "%0.25f", 0.1 + 0.2 }'
0.3000000000000000444089210
$ awk 'BEGIN { printf "%0.25f", 0.3 }'
0.2999999999999999888977698

Favicon file is empty

MYSQL FLOAT

Perhaps this example could explain.

CREATE TABLE test(fla FLOAT,flb FLOAT,dba DOUBLE(10,2),dbb DOUBLE(10,2));
We have a table like this:

+-------+-------------+
| Field | Type |
+-------+-------------+
| fla | float |
| flb | float |
| dba | double(10,2)|
| dbb | double(10,2)|
+-------+-------------+
For first difference, we try to insert a record with '1.2' to each field:

INSERT INTO test values (1.2,1.2,1.2,1.2);
The table showing like this:

SELECT * FROM test;

+------+------+------+------+
| fla | flb | dba | dbb |
+------+------+------+------+
| 1.2 | 1.2 | 1.20 | 1.20 |
+------+------+------+------+
See the difference?

We try to next example:

SELECT fla+flb, dba+dbb FROM test;
Hola! We can find the difference like this:

+--------------------+---------+
| fla+flb | dba+dbb |
+--------------------+---------+
| 2.4000000953674316 | 2.40 |
+--------------------+---------+

Source: https://stackoverflow.com/a/28511784/676479

[C++] setprecision() uses the std namespace

The C++ example is as follows:

std::cout << setprecision(17) << 0.1 + 0.2 << std.endl;

The function setprecision() uses the std namespace, and should therefore be written as such. Same goes for endl. Furthermore, the C example also works in C++; perhaps these should be merged?

Link to published website

Is this repo published somewhere? It would be a good idea to include a link to the published website in this repos README.md

Font size is too small

12px is much too small. I recommend leaving it at the default (normally 16px), and defining most other things in terms of ems or rems instead of pixels, and using max-width: 100% so that the greater width isn’t causing overflow trouble unnecessarily. (Mostly you could instead change widths to max-widths, but some bits may need to be told to be as wide as possible within that.)

Use of the word `decimals` is confusing

Use of the word decimals is confusing. For example:

In binary, 1 / 2, 1 / 4, 1 / 8 would all be expressed cleanly as decimals, while 1 / 5 or 1 / 10 would be repeating decimals

Here the first-use as decimals is correct, meaning when converted to decimal and written out, but the second-use is confusing; I think it means "digits after the binary-point". I don't think "decimals" is a good word to mean "digits after the binary-point".

I don't have a better word, just found it confusing. Please let me know if I got it all wrong. Awesome explanation though - love it :)

Rust example no longer valid

Seems the example is from before the stabilisation of Rust.

It should rather be something like this.

Proposal: move this to gh-pages

You could leverage gh-pages build to host this site and it would work with custom domain as well.
Or you could just push to gh-pages branch an have http://erikwiffin.github.io/0.30000000000000004 server as backup mirror.
If you consider switching to gh-pages with domain name, you can find instruction

Java has BigDecimal

This needs to be added as example as well to be fair.

Invalid SSL certificate

This is the certificate that is presented to me when I visit https://0.30000000000000004.com/:

The public key I was presented is issued to github.com etc..., not the domain.

Order by alphabetical order on Language

It would be nice if the examples were presented in a sorted alphabetical order by the first column, Language.