• Subject: Re: integer exponentiation with negative exponent
• From: Philipp Janda <siffiejoe@...>
• Date: Sat, 17 May 2014 08:31:47 +0200

```Am 17.05.2014 03:43 schröbte Leo Razoumov:
```
```On 4/29/14, Tim Hill <drtimhill@gmail.com> wrote:
```
```
“I agree with the original rationale (as outlined by Roberto, with some
reservations) that only the types of values affect the outcome, not the
values”.

```
```
In math the type of a result of a numeric operation DOES depend on the values
of the operands because some arithmetic operations (notably division)
are not closed in integers.
```
```
```
In maths, division is a partial function on integers (Z x Z -> Z), or an almost total function on rationals (Q x Q -> Q) (or some other compatible field). Integer division in C (and Lua it seems) just extends the partial function used in maths and does "something useful" for the undefined values, but the operation is still Z x Z -> Z, so the result type only depends on the operation, *not* the operand values.
```
```
Btw., does anyone know who invented integer division as defined in C in the first place? Is it used outside of programming?
```
```
```
For example, take division: 4/2 == 2: two integers go in and one
integer goes out and all the math properties of division
are preserved.
```
```
Or: Two rationals go in, one rational comes out.

```
```On the other hand, 5/3 poses a problem. You either
perform a floating point division which  changes
the type, or preserve the type by doing an integer division which
breaks associativity of the division.
```
```
```
I can see no problem: Two rationals go in, one rational comes out, *or* two integers go in, and the result is undefined (in maths)/some arbitrary integer (in C and Lua). Obviously, if you get a result that is undefined in maths, you can't expect it to follow the usual rules.
```
```
```If you insist you can have full type consistency but then do not call
them the arithmetic operations.
```
```
Why not?

```
```
By demanding type invariance one goes back to the arithmetic model of C
where you have to carefully track the numeric types.
```
```
```
It's easier to track types than values when looking at source code. And Lua's model is even easier than C's (at least for division): You don't have to know the operand types, just looking at the operator is enough to figure out the result type.
```
```
```Lua has a simple and consistent math based upon a single numeric type
-- 64-bit float.
```
```
```
That's about to change in Lua 5.3 (the "based upon a single numeric type" at least). The number of operations increased significantly, but I still think it's simple and consistent.
```
```
```
--Leo--

```
```
Philipp

```