Python floats are IEEE 754 double-precision binary floating-point numbers,\ncommonly referred to as \u201cdoubles\u201d, and take up 64 bits.\nOf those:<\/p>\n
- \n
- 1 is for the sign of the number;<\/li>\n
- 11 are for the exponent; and<\/li>\n
- 52 are for the fraction.<\/li>\n<\/ul>\n
![\"A diagram representing the 64 bits of doubles.\"](\"\/user\/pages\/02.blog\/04.til\/053.precision-of-python-floats\/_float_diagram_light.svg?decoding=auto&fetchpriority=auto\" "\\"A")
A diagram representing the 64 bits of doubles. Original by Codekaizen on Wikipedia, licensed under CC BY-SA 4.0.<\/figcaption><\/figure>\n We can verify experimentally that Python floats use 52 bits to store the fraction.\nThe number
1 << 53<\/code> is an exact integer:<\/p>\n>>> n = 1 << 53\n>>> n\n9007199254740992<\/code><\/pre>\nIn binary, this number is a
1<\/code> followed by 530<\/code>:<\/p>\n>>> bin(n)\n'0b100000000000000000000000000000000000000000000000000000'\n>>> bin(n)[2:]\n'100000000000000000000000000000000000000000000000000000'\n>>> bin(n)[2:].count(\"0\")\n53<\/code><\/pre>\nNow, if you convert
n<\/code> to a float and add1<\/code>, nothing happens;\nwhereas if you add2<\/code>, you get the correct value:<\/p>\n>>> float(n)\n9007199254740992.0\n>>> float(n) + 1\n9007199254740992.0\n>>> float(n) + 2\n9007199254740994.0<\/code><\/pre>\nWhy?<\/p>\n
Well,
n + 1<\/code> in binary starts and ends with1<\/code> and has 52 zeroes in the middle:<\/p>\n>>> bin(n + 1)\n'0b100000000000000000000000000000000000000000000000000001'<\/code><\/pre>\nRepresented in scientific notation (in binary), this number would have 53 digits after the decimal point:<\/p>\n
\\[\n1.00000000000000000000000000000000000000000000000000001_2 \\times 2^{53}\\]<\/p>\n
However, doubles only have 52 digits after the decimal point, so the final
1<\/code> is dropped and the number becomes<\/p>\n\\[\n1.0000000000000000000000000000000000000000000000000000_2 \\times 2^{53}\\]<\/p>\n
Which is exactly the same number.<\/p>\n
However, if we add
2<\/code> instead of just1<\/code>, the final result is<\/p>\n\\[\n1.00000000000000000000000000000000000000000000000000010_2 \\times 2^{53}\\]<\/p>\n
which looks like<\/p>\n
\\[\n1.0000000000000000000000000000000000000000000000000001_2 \\times 2^{53}\\]<\/p>\n
if we only use 52 digits after the decimal point, which is the same as the correct result.<\/p>\n
The fact that
n<\/code>,n + 2<\/code>,n + 4<\/code>, ... give the correct results,\nandn + 1<\/code>,n + 3<\/code>,n + 5<\/code>, ... don't,\ntogether with the fact that this phenomenon started atn = 1 << 53<\/code>\nand notn = 1 << 52<\/code> shows that Python floats use 52 bits to store the fraction of a number.<\/p>\nThat's it for now! Stay tuned<\/a> and I'll see you around!<\/p>","summary":"Today I learned what precision Python floats have.","date_modified":"2025-07-23T16:49:02+02:00","tags":["floats","mathematics","numerical analysis","programming","python"],"image":"\/user\/pages\/02.blog\/04.til\/053.precision-of-python-floats\/thumbnail.webp"},{"title":"TIL #021 \u2013 Spouge's formula","date_published":"2022-01-10T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/til\/021","url":"https:\/\/mathspp.com\/blog\/til\/021","content_html":"
Today I learned about Spouge's formula to approximate the factorial.<\/p>\n\n
![\"\"](\"\/images\/3\/5\/b\/c\/e\/35bcec4646bc80054d47a77cfc1d0a69b5377379-thumbnail.png\" "\\"Photo")
Photo by Scott Graham on Unsplash (cropped).<\/figcaption><\/figure>\n Spouge's formula<\/a><\/h2>\n
Spouge's formula allows one to approximate the value of the gamma function.\nIn case you don't know, the gamma function is like a generalisation of the factorial.<\/p>\n
In fact, the following equality is true:<\/p>\n
\\[\n\\Gamma(z + 1) = z!\\]<\/p>\n
where \\(\\Gamma\\)<\/span> is the gamma function.<\/p>\n
What Spouge's formula tells us is that<\/p>\n
\\[\n\\Gamma(z + 1) = (z + a)^{z + \\frac12}e^{-z-a}\\left( c_0 + \\sum_{k=1}^{a-1} \\frac{c_k}{z+k} + \\epsilon_a(z) \\right)\\]<\/p>\n
In the equality above, \\(a\\)<\/span> is an arbitrary positive integer and \\(\\epsilon_a(z)\\)<\/span> is the error term.\nThus, if we drop \\(\\epsilon_a(z)\\)<\/span>, we get<\/p>\n
\\[\n\\Gamma(z + 1) = z! \\approx (z + a)^{z + \\frac12}e^{-z-a}\\left( c_0 + \\sum_{k=1}^{a-1} \\frac{c_k}{z+k} \\right)\\]<\/p>\n
The coefficients \\(c_k\\)<\/span> are given by:<\/p>\n
\\[\n\\begin{cases}\nc_0 = \\sqrt{2\\pi} \\\\\nc_k = \\frac{(-1)^{k-1}}{(k - 1)!}(-k + a)^{k - \\frac12}e^{-k+a}, ~ k \\in \\{1, 2, \\cdots, a-1\\}\n\\end{cases}\\]<\/p>\n
By picking a suitable value of \\(a\\)<\/span>, one can approximate the value of \\(z!\\)<\/span> up to a desired number of decimal places.\nAlthough we need the factorial function to compute the coefficients \\(c_k\\)<\/span>,\nthose coefficients only need the factorial of numbers up to \\(a - 2\\)<\/span>.\nIf we are approximating \\(z!\\)<\/span>, where \\(a << z\\)<\/span>, then this approximation saves us some work.<\/p>\n
In order to determine the number of correct decimal places of the result,\none needs to control the error term \\(\\epsilon_a(z)\\)<\/span>.\nIf \\(a > 2\\)<\/span> and the \\(Re(z) > 0\\)<\/span> (which is always true if \\(z\\)<\/span> is a positive integer), then<\/p>\n
\\[\n\\epsilon_a(z) \\leq a^{-\\frac12}(2\\pi)^{-a-\\frac12}\\]<\/p>\n
By determining the value of \\(a^{-\\frac12}(2\\pi)^{-a-\\frac12}\\)<\/span>,\nwe can tell how many digits of the result will be correct.\nFor example, with \\(a = 10\\)<\/span>, we get<\/p>\n
\\[\na^{-\\frac12}(2\\pi)^{-a-\\frac12} \\approx 1.31556 \\times 10^{-9} ~ ,\\]<\/p>\n
meaning we will get 8 correct digits.<\/p>\n
\nHowever, notice that the approximating formula must, itself,\nbe computed with enough precision for the final result to hold\nas many correct digits as expected.\nIn other words, if a higher value of \\(a\\)<\/span> is picked so that the\nfinal result is more accurate, then we need to control the accuracy used when\ncomputing the coefficients \\(c_k\\)<\/span> and the formula itself.<\/p>\n<\/div>\n
I'll leave it as an exercise for you, the reader,\nto implement this approximation in your favourite programming language.<\/p>\n
Spouge's formula in APL<\/a><\/h2>\n
In APL, (and disregarding the accuracy issues) it can look something like this:<\/p>\n
\u235d Computes the `c_k` coefficients:\n Cks \u2190 {(.5*\u2368\u25cb2),((!ks-1)\u00f7\u2368\u00af1*ks-1)\u00d7((\u2375-ks)*ks-.5)\u00d7*\u2375-ks\u21901+\u2373\u2375-1}\n\n \u235d Computes the approximation of the gamma function:\n GammaApprox \u2190 {((\u2375+\u237a)*\u2375+.5)\u00d7(*-\u2375+\u237a)\u00d7(\u22a2\u00f71,\u2375+1\u2193\u2373\u2218\u2262)Cks \u237a}\n\n \u235d Computes an upper bound for the error term:\n Err \u2190 {(\u2375*\u00af.5)\u00d7(\u25cb2)*-\u2375+.5}\n\n a \u2190 10\n Err a\n1.315562187E\u00af9 \u235d Thus, we expect 8 decimal places to be correct.\n z \u2190 100\n a GammaApprox z\n9.332621544E157\n !z\n9.332621544E157<\/code><\/pre>\n