* test negative integers (small and big), too
* systematically test all possible juxtapositions of arguments for the
  operations that are covered
* sorted tests by which kernel function they exercise, and document the
  name of the function in a comment
* add tests for more functions (ModInt, ProdInt, AbsInt, ...)
* move PValuation tests to new file numtheor.tst (PValuation is not
  basic integer arithmetic, so it does not belong into intarith.tst)

We already did this, but for fewer values of k than possible,
and also using an inefficient integer division instead of a shift

This commit simplifies the code of PowInt, reducing code duplication.
This fixes a bug where 0^-LARGEINT returned 0, instead of raising an
error; and ensures that optimizations for certain special cases always
take effect, even if the exponent is large.

* NEW_INTNEG was commented out and also trivial to reimplement
* ProdIntObjFunc and PowObjIntFunc were declared but never used
* SMALLEST_INTPOS was exported to the language level, but unused

This change should be mostly irrelevant.; indeed, the C99
standard mandates that a%b and a%(-b) are equal, and even
on most pre-C99 compiler this holds true -- but not all.

We could instead also add a configure test, and reject compilers
violating this; in that case, we can obviously just stop checking
the sign of k.

In particular, if INTEGER_UNIT_SIZE ever differs from 2, 4, 8,
produce an error.

Also replace some tabs by spaces.

The result should also be a bit faster when comparing a small with a
large integer, as we immediately return false, instead of first
converting the small integer into a large one, then calling mpn_cmp.
This relies on all integers always being normalized and reduced.

We cannot simply use ABS_INT and SIGN_INT, as one might expect
given the names AbsInt/SignInt, as a lot of library code (and
likely in packages and elsewhere) is relying on the undocumented
fact that the old AbsInt and SignInt implementations also worked
for rationals.

AbsoluteValue used to invoke AbsInt on non-integer rationals.
While this works, this is undocumented

This was added 2010-11-02 as an experimental feature by Laurent.
But it was never documented, nor hooked up to anything, or usable
without modifying the library.

This allows us to optimize it.

Before returning the computed result, ModInt checked whether it was
negative, it flipped the sign. This should (a) never be necessary,
because the preceding computations should always produce something
non-negative, and (b) would be mathematically incorrect.

Instead, we simply return the result untreated, and added an assertion
triggering if we ever see a negative result here (only enabled if
DEBUG_GMP is set).

To turn this on, #define DEBUG_GMP 1

This fix a bug, as IntHexString could return a non-reduced integer.