# Does base-10 seem natural only because we have ten fingers? **URL:** \ **Category:** Factual Questions\ **Created:** [March 1, 2012, 7:17pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476 "2012-03-01T19:17:09Z")\ **Posts on this page:** 20\ **Page:** 2
**Author:** ![Bytegeist](https://avatars.discourse-cdn.com/v4/letter/b/9dc877/32.png) [@Bytegeist](https://boards.straightdope.com/u/Bytegeist)\ **Post date:** [March 2, 2012, 12:13am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/21 "2012-03-02T00:13:58Z")
> [@MilTan](#): > > Did you mean that a “decimal” representation of a rational would be less likely to require a repeating representation? If you want to represent a rational as “a.b”, then the more divisors there are in the base, the less likely it is that b will need to be a repeated figure. For that particular goal, it’s not the number of divisors in the base that matter, but the number of unique prime factors. (So, base 36 is no improvement over base 18, or even base 6.) ---
**Author:** ![Indistinguishable](https://avatars.discourse-cdn.com/v4/letter/i/90ced4/32.png) [@Indistinguishable](https://boards.straightdope.com/u/Indistinguishable)\ **Post date:** [March 2, 2012, 1:10am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/22 "2012-03-02T01:10:17Z")
> [@Voyager](#): > > You wouldn’t be laughing if you had to write code to deal with the fact that putting two bytes together with values 377 and 377 does not yield 377377 but rather 177777. > > Dumb, dumb, dumb! Wait, I wasn’t laughing in the first place… I’m all for hexadecimal over octal. My post was sincere, not mockery. ---
**Author:** ![standingwave](https://avatars.discourse-cdn.com/v4/letter/s/9de0a6/32.png) [@standingwave](https://boards.straightdope.com/u/standingwave)\ **Post date:** [March 2, 2012, 1:56am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/23 "2012-03-02T01:56:42Z")
> [@Jackknifed\_Juggernaut](#): > > Don’t you mean 16 months ago? 😉 😛 ---
**Author:** ![Senegoid](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/senegoid/32/6606_2.png) [@Senegoid](https://boards.straightdope.com/u/Senegoid)\ **Post date:** [March 2, 2012, 8:35am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/24 "2012-03-02T08:35:40Z")
> [@chrisk](#): > > Now, there are also tradeoffs involving the size of the base. Binary has few digits to remember, but fairly long representations to express a given number. Base 36 would go the other way - numbers would take significantly fewer digits than in base 10, but there’s more different digits to keep track of. **But since we can keep track of 26 letters in language, base 36 math is something that we could probably handle. We could even combine the arabic digits and the latin letters to come up with a digit set that would be fairly easy to remember the order of, as long as we remembered that A comes after 9, or whatever.** I doubt that base 36 would be so easy. Can you imagine having to memorize your times tables in base 36? Or even your add tables, for that matter. Lower bases, in the 8 to 16 range, would have the advantage there. > [@Chronos](#): > > Indeed. I once worked on a project where I literally found it **simplest to work in base eleven. Which, of course, would be an absolutely horrid choice** of base for most situations. And could you imagine a more horrid choice of base than 2.71828182845904523536028747135266249775724709369995957496696762772407663035354 ? Who would EVER choose a fractional number (let alone one with LOTS of decimal digits) as a base? 😃 > [@Derleth](#): > > Side note: Floating-point math, i.e. how computer people have turned the field of the real numbers into something utterly bizarre, is currently done in base 2, so something the equivalent of 0.1 is 1/2, and 0.01 is 1/4. Now, in that representation, one-tenth is a bizarre repeating decimal which frequently doesn’t round quite right. Therefore, in a computer, 10 \* 0.1 may or may not exactly equal 1. > > The average application programmer approaches floating-point-intensive code with the same reverent awe and voodoo incantiation you might find in a Santeria ritual. I wrote a little essay about THAT not long ago, harping on the fact that so few programmers have a clue about this. **CookingWithGas** and **Chronos** entered posts agreeing, and we got into a discussion there about how best to compare floating-point number to get programs to do the right things. > [@Date puzzle](https://boards.straightdope.com/t/date-puzzle/611700/4): > > Here’s a programming exercise every programmer should try at least once in his/her career: > > Code and run this program in as many languages as you can, correcting the syntax as necessary for each language (C/C++, Java, JavaScript, PHP, T-SQL, bash, perl, Fortran, Algol, Cobol, Pascal, Visual Basic, even bare-bones assembly languages). Change the print statements to display the output any way that’s convenient. Compare the results. Do all compilers and interpreters produce the same result? Can you explain what is happening? > > float tenth, unity, addEmUp ; > tenth = 0.1 ; > unity = 1.0 ; > addEmUp = tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth ; > if ( addEmUp == unity ) { > print “There is sanity in the world.” ; > } > else { > print “The gods must be crazy.” ; > } Well? How many of you programmers out there HAVE done this, or similar, exercise at least once in your career? I keep harping on this because of the non-ending trouble I have had in working with, or supporting, other people’s code that does this wrong. ETA: I’ve also noticed that: addEmUp = tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth ; doesn’t always produce the same result as: addEmUp = tenth \* 10.0 ; Go figure. Might have something to do with compiler code optimization or something. ---
**Author:** ![Indistinguishable](https://avatars.discourse-cdn.com/v4/letter/i/90ced4/32.png) [@Indistinguishable](https://boards.straightdope.com/u/Indistinguishable)\ **Post date:** [March 2, 2012, 8:52am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/25 "2012-03-02T08:52:50Z")
> [@Derleth](#): > > Floating-point math, i.e. how computer people have turned the field of the real numbers into something utterly bizarre To be fair, there are natural reasons why one might want to use a finite datatype for many purposes, and there aren’t any finite ordered fields, so something was bound to go bizarre from the start… ---
**Author:** ![DSeid](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/dseid/32/20194_2.png) [@DSeid](https://boards.straightdope.com/u/DSeid)\ **Post date:** [March 2, 2012, 12:53pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/26 "2012-03-02T12:53:27Z")
As an aside we have base 12 (it’s “eleven” and “twelve”, rather than "oneteen and “twoteen”, and we count by dozens in many circumstances) and base 60 mixed thanks to finger counting as well: Count the phalanges on one hand with your thumb - you count to twelve once. Mark that dozen by flipping up your thumb on the other hand and keep counting (One dozen one, two …) and after that dozen flip up another finger on the other hand. Fill up that hand and you have sixty. ---
**Author:** ![Francis\_Vaughan](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/francis_vaughan/32/3093_2.png) [@Francis\_Vaughan](https://boards.straightdope.com/u/Francis_Vaughan)\ **Post date:** [March 2, 2012, 1:05pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/27 "2012-03-02T13:05:08Z")
We used to teach a subject called numerical methods - which was a one semester course in basic computer numerical algorithms. Lecture 1 was about machine epsilon. However the subject hasn’t been offered in a very long time. This is not a good thing. (There was a follow up course on numerical analysis which taught the core stuff, the methods course really taught students enough that they wouldn’t get into trouble doing stupid things. Nowadays they do get into trouble doing stupid things.) One might note that there is nothing special about computers and binary notation that makes it susceptible to these problems. You can cook them up in any base. (Which is essentially what **Indistinguishable** said above.) > [@](#): > > addEmUp = tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth ; > doesn’t always produce the same result as: > addEmUp = tenth \* 10.0 ; > Go figure. Might have something to do with compiler code optimization or something. They are different expressions. The first one is the sum of exactly 10 copies of _tenth_. The second expression is the multiplication of the floating point number 10.0 by the floating point number tenth. These expressions are different for exactly the reason being complained about. 10.0 is not the same number as 10. Many languages will automatically convert 10 to 10.0 when needed in a mixed mode expression. But not all - some require explicit conversions. And it is well understood that the conversion is fraught with issues. In languages with conversion rules 10 \* tenth would be silently converted to 10.0 \* tenth. But the expression _tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth_ will not be. ---
**Author:** ![CookingWithGas](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/cookingwithgas/32/485_2.png) [@CookingWithGas](https://boards.straightdope.com/u/CookingWithGas)\ **Post date:** [March 2, 2012, 1:32pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/28 "2012-03-02T13:32:48Z")
> [@Senegoid](#): > > I wrote a little essay about THAT not long ago, harping on the fact that so few programmers have a clue about this. **CookingWithGas** and **Chronos** entered posts agreeing, and we got into a discussion there about how best to compare floating-point number to get programs to do the right things. BTW [here is a page](http://books.google.com/books?id=r6Fi2beH8xkC&pg=PA103&lpg=PA103&dq=safe+numbers+programming&source=bl&ots=zG9mK_1r2J&sig=Gtuf8_7zCUqNuGONDBwolxVJefE&hl=en&sa=X&ei=N8pQT_OYGMrr0gHawLTmDQ&sqi=2&ved=0CD8Q6AEwAg#v=onepage&q&f=false) from a book giving the rationale for design decisions for the Ada programming language. It was written by the lead designer. This page talks about model numbers (numbers which are required to be represented exactly on a machine to be compliant with the Ada specification) and safe numbers (numbers which can be represented exactly on a particular[del]any given[/del] machine). [Here is a page](http://books.google.com/books?id=jA9qIiErN2EC&pg=SA3-PA19&lpg=SA3-PA19&dq=%22safe+numbers%22+programming&source=bl&ots=_ak75CIafe&sig=WOxshJEzbtn3KoOwubdBoWG6USc&hl=en&sa=X&ei=hstQT-f9E8bZ0QGWrYjGDQ&ved=0CEQQ6AEwBQ#v=onepage&q=%22safe%20numbers%22%20programming&f=false) on the same topic from the reference manual. Ada has long since fallen out of favor, and I think these terms were coined for Ada rather than being industry standard, but the concepts are universal. ---
**Author:** ![Senegoid](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/senegoid/32/6606_2.png) [@Senegoid](https://boards.straightdope.com/u/Senegoid)\ **Post date:** [March 2, 2012, 9:57pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/29 "2012-03-02T21:57:22Z")
> [@Francis\_Vaughan](#): > > We used to teach a subject called numerical methods - which was a one semester course in basic computer numerical algorithms. Lecture 1 was about machine epsilon. However the subject hasn’t been offered in a very long time. This is not a good thing. (There was a follow up course on numerical analysis which taught the core stuff, the methods course really taught students enough that they wouldn’t get into trouble doing stupid things. Nowadays they do get into trouble doing stupid things.) > > \ > > They are different expressions. The first one is the sum of exactly 10 copies of _tenth_. The second expression is the multiplication of the floating point number 10.0 by the floating point number tenth. These expressions are different for exactly the reason being complained about. 10.0 is not the same number as 10. Many languages will automatically convert 10 to 10.0 when needed in a mixed mode expression. But not all - some require explicit conversions. And it is well understood that the conversion is fraught with issues. In languages with conversion rules 10 \* tenth would be silently converted to 10.0 \* tenth. But the expression _tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth + tenth_ will not be. I can see that tenth \* 10.0 might produce a different result than tenth + tenth + …, but I would expect _neither_ of them to compare exactly equal to 1.0 (ETA: And I expect that 1.0 would always be represented correctly and exactly.) And I would always expect any (reasonably sized) _integer,_ when converted to a float, to be exact. So tenth \* 10 should be identical to tenth \* 10.0 providing that the language allows it at all. When I took Computer Science classes at U. C. Berkeley in the early 1970’s, the major also required a Numerical Analysis course (in the Math department), although I never took it. So what minimal understanding I have, I’ve just picked up over the years. That class is a full semester (or quarter) of heavy-duty mathematical number-crunching. But for the non-so-mathematically-inclined, I think that all basic programming classes should at least teach some basics, for maybe two or three lectures’ worth or so. As far as I know, this is not done. I remember being utterly gabberflasted when a friend first pointed out to me that 0.1[sub]10[/sub] is a non-terminating [del]decimal[/del] thingy when expressed in binary. I really think the above programming exercise that I recommended (which I invented myself) should be a required exercise for all first-semester programming students, regardless of what programming language they are using. (I vaguely remember having tried it with Visual Basic, and the numbers compared equal. Does VB use some kind of finagle-factor in comparing floats, to “protect” the naive programmers who use VB?) ---
**Author:** ![Senegoid](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/senegoid/32/6606_2.png) [@Senegoid](https://boards.straightdope.com/u/Senegoid)\ **Post date:** [March 2, 2012, 10:05pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/30 "2012-03-02T22:05:45Z")
> [@CookingWithGas](#): > > BTW [here is a page](http://books.google.com/books?id=r6Fi2beH8xkC&pg=PA103&lpg=PA103&dq=safe+numbers+programming&source=bl&ots=zG9mK_1r2J&sig=Gtuf8_7zCUqNuGONDBwolxVJefE&hl=en&sa=X&ei=N8pQT_OYGMrr0gHawLTmDQ&sqi=2&ved=0CD8Q6AEwAg#v=onepage&q&f=false) from a book giving the rationale for design decisions for the Ada programming language. It was written by the lead designer. This page talks about model numbers (numbers which are required to be represented exactly on a machine to be compliant with the Ada specification) and safe numbers (numbers which can be represented exactly on a particular[del]any given[/del] machine). [Here is a page](http://books.google.com/books?id=jA9qIiErN2EC&pg=SA3-PA19&lpg=SA3-PA19&dq=%22safe+numbers%22+programming&source=bl&ots=_ak75CIafe&sig=WOxshJEzbtn3KoOwubdBoWG6USc&hl=en&sa=X&ei=hstQT-f9E8bZ0QGWrYjGDQ&ved=0CEQQ6AEwBQ#v=onepage&q=%22safe%20numbers%22%20programming&f=false) on the same topic from the reference manual. Google won’t let me see either of those pages. (Do I have to be a subscriber or something?) ---
**Author:** ![Sunspace](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/sunspace/32/1250_2.png) [@Sunspace](https://boards.straightdope.com/u/Sunspace)\ **Post date:** [March 2, 2012, 10:06pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/31 "2012-03-02T22:06:53Z")
If only we had had a base-twelve numerical system when we invented the metric system. Then it would be the best of both worlds… “I’ll have a quarter-kilo of lentils and a third of a kilo of beans…” ---
**Author:** ![TBG](https://avatars.discourse-cdn.com/v4/letter/t/c89c15/32.png) [@TBG](https://boards.straightdope.com/u/TBG)\ **Post date:** [March 2, 2012, 10:27pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/32 "2012-03-02T22:27:08Z")
There are 10 kinds of people on the SDMB, those that understand what’s going on in this topic and those who don’t ---
**Author:** ![JohnGalt](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/johngalt/32/184_2.png) [@JohnGalt](https://boards.straightdope.com/u/JohnGalt)\ **Post date:** [March 2, 2012, 11:03pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/33 "2012-03-02T23:03:06Z")
> [@Senegoid](#): > > I really think the above programming exercise that I recommended (which I invented myself) should be a required exercise for all first-semester programming students, regardless of what programming language they are using. (I vaguely remember having tried it with Visual Basic, and the numbers compared equal. Does VB use some kind of finagle-factor in comparing floats, to “protect” the naive programmers who use VB?) I teach beginning programming at a state technical college, and yes, we do cover this topic every time we discuss conditional operations. It takes an actual run printing out the results of an if statement (in both Java and C++) for them to be aware of the problem. It’s also one of my test questions on the midterm exam! In Visual Basic and in C-Sharp, Microsoft has both the double format for the binary approximation of a floating point number, and a decimal format which keeps the result in pure decimal form. In fact, the formatting codes for decimal uses ‘M’ for money. We discuss _Office Space_ when talking about double and decimal - as programmers, this is one way they could get rich! ---
**Author:** ![Francis\_Vaughan](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/francis_vaughan/32/3093_2.png) [@Francis\_Vaughan](https://boards.straightdope.com/u/Francis_Vaughan)\ **Post date:** [March 3, 2012, 12:08am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/34 "2012-03-03T00:08:38Z")
> [@](#): > > I can see that tenth \* 10.0 might produce a different result than tenth + tenth + …, but I would expect neither of them to compare exactly equal to 1.0 (ETA: And I expect that 1.0 would always be represented correctly and exactly.) Yes, 1.0 will represent exactly. Where you may still get into trouble is when using it in an expression. The implementation of the floating point hardware comes into play. 0.1 uses all the bits, and the least significant bit becomes a problem. > [@](#): > > And I would always expect any (reasonably sized) integer, when converted to a float, to be exact. So tenth \* 10 should be identical to tenth \* 10.0 providing that the language allows it at all. Yes, where “reasonable sized” means that you can represent it within the mantissa of the floating point number without truncation. That gets you 24 bits in IEEE single precision. However again, you remain at the mercy of the floating point hardware for the exact result. The least significant bit could easily vary. Usually the FPU will calculate the result to more bits of precision than the base width and round the result. However the precise rounding rules can vary, and you can’t rely on the value of the LSB being identical on all platforms. ---
**Author:** ![Dr.Strangelove](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/dr.strangelove/32/6613_2.png) [@Dr.Strangelove](https://boards.straightdope.com/u/Dr.Strangelove)\ **Post date:** [March 3, 2012, 1:01am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/35 "2012-03-03T01:01:07Z")
> [@Francis\_Vaughan](#): > > However again, you remain at the mercy of the floating point hardware for the exact result. The least significant bit could easily vary. Usually the FPU will calculate the result to more bits of precision than the base width and round the result. However the precise rounding rules can vary, and you can’t rely on the value of the LSB being identical on all platforms. I have never seen a system where you could not depend on exact integer-\>float conversion for smallish ints. I don’t understand where the LSB comes into play. If you try to convert 16777215, the computer should, without exception, give you a float value of 0b01001011011111111111111111111111. There is no uncertainty in the LSB because there is no rounding to be done. Now if you had tried to store 16777217, then maybe on some languages/OSes you get 0b01001011100000000000000000000000 while on others you get 0b01001011100000000000000000000001, depending on the rounding behavior. Even so, the actual machine shouldn’t make a difference–this is a question of how the language or OS libraries convert the text representation of the float into the binary representation. That detail has very little to do with the hardware it runs on. Of course, once you multiply the numbers, all bets are off, because multiplication in general requires a doubling of precision for exact storage. ---
**Author:** ![MilTan](https://avatars.discourse-cdn.com/v4/letter/m/71e660/32.png) [@MilTan](https://boards.straightdope.com/u/MilTan)\ **Post date:** [March 3, 2012, 2:23am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/36 "2012-03-03T02:23:03Z")
> [@Dr.Strangelove](#): > > I have never seen a system where you could not depend on exact integer-\>float conversion for smallish ints. Right – in IEEE single-precision format, there are 23 bits in the significand, with an implied 1 at the beginning, and an additional sign bit, so you can represent all integers from -(2^24 - 1) to (2^24 - 1) precisely. But any fraction whose reduced denominator is not a power of 2 (such as 0.1) can’t be represented precisely. ---
**Author:** ![Darryl\_Lict](https://avatars.discourse-cdn.com/v4/letter/d/7cd45c/32.png) [@Darryl\_Lict](https://boards.straightdope.com/u/Darryl_Lict)\ **Post date:** [March 3, 2012, 4:01am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/37 "2012-03-03T04:01:04Z")
> [@friedo](#): > > On the other hand, a system with too many symbols (say, the base-60 system used by the Babylonians, from which we get our 60-divided time units) can also be difficult. There are a lot of symbols to learn, and there are only so many ways to differentiate symbols on a clay tablet without a lot of them looking similar, leading to mistakes. And actually, although the Babylonian system was positional, their “digits” were really composed of smaller symbols. I was curious about this, so I looked up the [Wikipedia entry](http://en.wikipedia.org/wiki/Babylonian_numerals#Numerals) on Babylonian base 60 numbering and interesting enough, the symbols from 1 to 59 are actually in base 10. ---
**Author:** ![crowmanyclouds](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/crowmanyclouds/32/19884_2.png) [@crowmanyclouds](https://boards.straightdope.com/u/crowmanyclouds)\ **Post date:** [March 3, 2012, 6:01am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/38 "2012-03-03T06:01:07Z")
> [@DSeid](#): > > … Count the phalanges on one hand with your thumb - you count to twelve once. Mark that dozen by flipping up your thumb on the other hand and keep counting (One dozen one, two …) and after that dozen flip up another finger on the other hand. Fill up that hand and you have sixty. … Counting to something more than ten on your hands, say to [100](http://en.wikipedia.org/wiki/Chisanbop) or [1,023](http://en.wikipedia.org/wiki/Finger_binary), isn’t a hardware problem it’s the software. CMC fnord! ---
**Author:** ![2sense](https://avatars.discourse-cdn.com/v4/letter/2/e47774/32.png) [@2sense](https://boards.straightdope.com/u/2sense)\ **Post date:** [March 3, 2012, 7:56am UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/39 "2012-03-03T07:56:06Z")
> [@DSeid](#): > > Count the phalanges on one hand with your thumb - you count to twelve once. Mark that dozen by flipping up your thumb on the other hand and keep counting (One dozen one, two …) and after that dozen flip up another finger on the other hand. Fill up that hand and you have sixty. How do you get 12 by counting phalanges? I have five fingers and toes on each hand or foot. ---
**Author:** ![Francis\_Vaughan](https://sea3.discourse-cdn.com/straightdope/user_avatar/boards.straightdope.com/francis_vaughan/32/3093_2.png) [@Francis\_Vaughan](https://boards.straightdope.com/u/Francis_Vaughan)\ **Post date:** [March 3, 2012, 1:26pm UTC](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476/40 "2012-03-03T13:26:29Z")
> [@](#): > > Of course, once you multiply the numbers, all bets are off, because multiplication in general requires a doubling of precision for exact storage. Exactly. That was my point. The question was why 10 \* 0.1 behaved differently to 0.1 + 0.1 + … + 0.1 - and it is the multiplication of 0.1 by 10.0 versus 10 floating point additions that gets you there. On reflection, my use of the word “result” was probably not as obvious as it might have been. “Result” referred to the result of the expressions - not the conversion from int to float. [Previous page](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476.md?page=1) [Next page](https://boards.straightdope.com/t/does-base-10-seem-natural-only-because-we-have-ten-fingers/614476.md?page=3)