Integer Division is incorrect

[wduquette]

The expr command has an error. The expression M/N should always return 0 where M and N are integers and M < abs(N). This works correctly if N is positive, but if N is negative the result is -1 if M is positive, and 1 if M is negative.

% expr {1/-2}
-1
% expr {-1/-2}
1

The magnitude of the divisor doesn't matter, so long as abs(M) < abs(N).

[wduquette]

In fact, this appears to be a general problem with the divisor is negative:

% expr {11/-10}
-2
% expr {-11/-10}
2

[wduquette]

The TCL 7.6 expr code contains a complex little algorithm to give consistent remainders with negative divisors across C compilers. This may still be an issue in Rust across platforms; but the translated code does the wrong thing, and inspecting it I can't see how the C code ever did the right thing. I've replaced it with a naive algorithm, and it seems to work. I'll need to check remainders separately.

[wduquette]

Whoops! I notice that TCL 8.6 gives the same answers as TCL 7.6, which implies that the answers are correct if counter intuitive. ????

Reopening until I understand what's going on.

[wduquette]

Here's a table of results I've compiled.

Operation	TCL 7.6	TCL 8.6	Molt	Rust
12 / 10	1	1	1	1
12 % 10	2	2	2	2
-12 / 10	-2	-2	-1	-1
-12 % 10	8	8	-2	-2
12 / -10	-2	-2	-2	-1
12 % -10	-8	-8	-8	2
-12 / -10	1	1	2	1
-12 % -10	-2	-2	8	-2

From this, we see:

• TCL reliably rounds toward negative infinity; Rust reliably rounds toward 0.
• C must reliably round toward negative infinity if the denominator is positive, since TCL 7.6 has no special code for that case, and is getting the same answer as TCL 8.6.
• Rust does not, and so Molt (which like TCL 7.6, does nothing special in that case) is getting the same answer as Rust.
• And because of this, when both numerator and denominator are negative Molt is simply wrong.

The question now is, which behavior is preferable for Molt? Consistency with the host language (appropriate for an extension language) or consistency with long-established TCL practice?

[wduquette]

Per Kevin Kenny:

• TCL used to do whatever the underlying C compiler did.
• At some point, it was decided to standardize on rounding toward negative infinity.
  • So that the same code could run on different platforms
  • So that test outcomes weren't platform dependent
  • And there were some nice numerical advantages.
• Since then, C99, Python 3, and Rust, among others, have standardized on rounding toward zero.
• Molt will now round toward zero:
  • This is what Rust does, and a Rust extension language should do arithmetic the same way Rust does.
  • It will be less confusing to newcomers.
  • It's simpler to implement, since it's what Rust does.

Kevin insists that the / and % must be defined consistently, i.e., that the following equation holds for integer a and b, where b is not zero:

b*(a/b) + (a%b) == a