The new function is taken from the Python version of float_divmod and
computes the result of floor_division and modulus together so that they
can be kept compatible. This should also result in the '//' and '%'
operators applied to np.float64 and Python float returning the same
values.

The intent is to implement the ufuncs floor_divide and remainder using
the npy_divmod so that their results will also match those of '//' and
'%' while providing consistency between the two.

Note that npy_divmod uses fmod, which is very slow. As a result, the
floor_division and remainder functions are about 4x slower than the
previous versions based on the floor function, but should be more
accurate.

The following numpy scalar floating functions are reimplemented
using the npy_divmod function.

- remainder ('%')
- floor_division ('//')
- divmod

Note that numpy scalars warn on zero division rather than raise.

divmod example, Python floats

    In [1]: a = 78 * 6e-8

    In [2]: b = 6e-8

    In [3]: divmod(a, b)
    Out[3]: (77.0, 5.999999999999965e-08)

Before this commit numpy float64 gave

    In [4]: divmod(float64(a), float64(b))
    Out[4]: (78.0, 0.0)

After this commit numpy float64 gives

    In [4]: divmod(float64(a), float64(b))
    Out[4]: (77.0, 5.9999999999999651e-08)

The floor function is no longer needed in scalarmath as its use has been
replaced by the new pymodf function.

The following numpy ufuncs are reimplemented using the npy_divmod
function.

- remainder ('%')
- floor_divide ('//')

Example of differences

Currently

    In [1]: a = np.array(78 * 6e-8)

    In [2]: b = np.array(6e-8)

    In [3]: a // b
    Out[3]: 77.0

    In [4]: a % b
    Out[4]: 5.9999999999999651e-08

Previously

    In [1]: a = np.array(78 * 6e-8)

    In [2]: b = np.array(6e-8)

    In [3]: a // b
    Out[3]: 78.0

    In [4]: a % b
    Out[4]: 0.0

The first agrees with the Python values for the same operation and is a
bit more accurate for the input values as represented internally.

Closes numpy#7224.

Add tests for some corner cases involving inf, zero, and nan.
Check that small integers are handled exactly.

The floor_divide (//) and remainder (%) functions are complementary
in the sense that a ~= (a % b) + (a // b).