Has everyone forgotten Pascal?

1/6 yields 0.1666666... (to whatever precision is supported).

1 div 6 yields 0

It’s arguable whether the C rule is a mistake. Almost all of C’s arithmetic operators, where the operands are of the same type, yield a result of the same type. There’s something to be said for consistency.

Furthermore, since C is primarily targeted at system-level code, most C programs don’t use floating-point at all. At one time, accidentally adding floating-point code to a program that didn’t otherwise need it could be a serious problem. That’s probably still the case, for small embedded systems — which, again, are a major target for C.

In most C programs, truncating integer division is probably just what you want anyway.

If 1 / 6 yielded a floating-point result in C, then:

• It would be an inconsistency in the language.
• The standard would have to make an arbitrary choice of which floating-point type to use for the result (double may seem like the natural choice, but you might prefer the extra precision of long double)
• The language would still have to have an operation for integer division; performing floating-point addition and then truncating would likely not be good enough.

C could have provided separate operators for the two kinds of division, but the second point above would still apply: which of the three floating-point types would be used for the result? And since it’s easy enough to get floating-point division if you need it (use a floating-point constant for one or both of the operands, or cast one or both of the operands to a floating-point type), it apparently wasn’t considered that important.

In the 1974 version of the C manual (that’s 4 years before the publication of the first edition of K&R), Ritchie doesn’t even mention the possible confusion:

The binary / operator indicates division. The same type considerations as for multiplication apply

which says that if both operands are of type int or char, the result is of type int.

Yes, it’s a source of confusion for some C programmers, especially beginners — but C is not noted for being very novice-friendly.

Actually this behavior was changed in Python 3 and it now does behave like you expect (// is now used for integer division).

Out of prominent languages, JavaScript. 1.0/6.0 = 1/6 =
0.16666666666666666.

I don’t see this as surprising. As a rule of a thumb, if a language distinguishes between integer and floating point numeric types, dividing two integers will yield a truncated integer instead of float. If it doesn’t, most likely it will default to floating point operations. This should be the expected behaviour on the programmer’s part.

Just keep in mind that there are additional things that could also be at play here, like the already mentioned separate integer division operator or implicit type casting.

There are many languages where ((1/6)*6) results in 1, not in 0. For example, PL/SQL, many BASIC dialects, Lua.

_{Accidentally, in all those langauges 1/6 results in .166666667, or 0.16666666666667 or something similar. I chose the ((1/6)*6)==1 variant to get rid of those little differences.}

Haskell treats 1/6 and 1.0/6.0 as being identically 0.16666666666666666. It also renders 1/6.0 and 1.0/6 as being that same value as well.

This is due to the basic numerical types in Haskell not being quite the same as other languages. True integer division is somewhat…complicated.

Yes, Perl does. The one-liner

perl -e '$x=1/6;print "$xn";'

results in the output of:

0.166666666666667

I believe that PHP works the same way.

Edited to add: I also believe that a necessary (but not sufficient) condition for 1/6 == 1.0/6.0 is for the language in question to be weakly typed.

In Squeak Smalltalk / on integers creates Fraction objects. So while this is not the same as float division, still (1/6)*6 returns 1.

Yes, I just checked my TI-99/4A’s built in TI BASIC. As it treats all numeric expressions as floating point, the division operation is floating point as well.

 TI BASIC READY
>PRINT 1/6
  .1666666667

>

VB (VB.Net , VB6, VBA…)

The integer division operator is

MATLAB. Numeric literals are doubles by default.

>> 1/6
ans =
    0.1667

Clojure does use fractions by default. It’s not the same as 1.0/6.0, but you can convert to it with float or double when you need.

user=> (/ 1 6)
1/6
user=> (* (/ 1 6) 2)
1/3
user=> (pos? (/ 1 6)) ; Is 1/6 > 0?
true
user=> (float (/ 1 6))
0.16666667

Surprisingly, it seems to work properly in Windows PowerShell (version 3).

PS C:> 1.0 / 6.0
0.166666666666667

PS C:> 1/6
0.166666666666667

Also seems to work in Python 3 as sepp2k mentioned. The other two languages I have readily available on REPL, Scala and Ruby, both do integer division and yield 0.

The Rexx language always produces an arithmetically correct answer. For example: 5/2 = 2.5. Rexx is a great language that has not been utilized enough. In theory, when a compiler can’t determine what do you want, its better to do the correct math, however, this may not be efficient. Rexx also provides the // operator.