rem returns zero for negative float input on ARMv7

[kimikage]

To check the modification for the issue #129, I ran the tests on a 32-bit ARMv7 system (RPi 2 Model B v1.2). And then, I faced a problem with rem (%).

modulus: Test Failed at ~/.julia/dev/FixedPointNumbers/test/normed.jl:148
  Expression: (-0.3 % N0f8).i == round(Int, -0.3 * 255) % UInt8
   Evaluated: 0x00 == 0xb4
modulus: Test Failed at ~/.julia/dev/FixedPointNumbers/test/normed.jl:154
  Expression: (-0.3 % N6f10).i == round(Int, -0.3 * 1023) % UInt16
   Evaluated: 0x0000 == 0xfecd

The cause is the behavior of unsafe_trunc.

FixedPointNumbers.jl/src/normed.jl

Line 103 in 70ae1d6

rem(x::Real, ::Type{T}) where {T <: Normed} = reinterpret(T, _unsafe_trunc(rawtype(T), round(rawone(T)*x)))

FixedPointNumbers.jl/src/normed.jl

Lines 204 to 205 in 70ae1d6

	_unsafe_trunc(::Type{T}, x::Integer) where {T} = x % T
	_unsafe_trunc(::Type{T}, x) where {T} = unsafe_trunc(T, x)

julia> versioninfo()
Julia Version 1.0.3
Platform Info:
  OS: Linux (arm-linux-gnueabihf)
  CPU: ARMv7 Processor rev 4 (v7l)
  WORD_SIZE: 32
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.0 (ORCJIT, cortex-a53)

julia> unsafe_trunc(UInt8, -76.0) # or the intrinsic `fptoui`
0x00

julia> unsafe_trunc(Int8, -76.0)
-76

julia> unsafe_trunc(UInt8, unsafe_trunc(Int8, -76.0))
0xb4

(The problem occurs not only on v1.0.3 but also on v1.0.5 and v1.2.0. I have not tried the 64-bit.)

Although the behavior of unsafe_trunc may not be what we want, this is not a bug.

If the value is not representable by T, an arbitrary value will be returned.

https://docs.julialang.org/en/v1/base/math/#Base.unsafe_trunc

However, I don't think it is good to make the rem users aware of the internal unsafe_trunc.
The workaround is to convert the value to Signed temporarily as shown above.

BTW, the behavior of Normed's rem, which is specified by the above tests seems to be not intuitive. (Since I know the inside of Normed, I think the behavior is reasonable, though.)
So, I think it is another option to eliminate the tests for negative float inputs, i.e. make it an undefined behavior.

[kimikage]

I added the following workaround into "src/normed.jl".

if !signbit(signed(unsafe_trunc(UInt, -12.345)))
    # a workaround for 32-bit ARMv7 (issue #134)
    function _unsafe_trunc(::Type{T}, x::AbstractFloat) where {T}
        unsafe_trunc(T, unsafe_trunc(typeof(signed(zero(T))), x))
    end
end

Although it took much more time than expected, all tests were passed on ARM Cortex-A53.:tada:

julia> versioninfo()
Julia Version 1.0.3
Platform Info:
  OS: Linux (arm-linux-gnueabihf)
  CPU: ARMv7 Processor rev 4 (v7l)
  WORD_SIZE: 32
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.0 (ORCJIT, cortex-a53)

Test Summary: |     Pass     Total
normed        | 62954923  62954923
Test Summary: |  Pass  Total
fixed         | 31886  31886
Test Summary: | Pass  Total
traits        |  251    251
   Testing FixedPointNumbers tests passed

[kimikage]

Since 8-/16-bit types are converted via Int32, there is no overflow in the range from typemin to typemax. However, conversion to UInt32 clamps the result with typemax(Int32) (on ARM).

julia> unsafe_trunc(Int32, Float64(typemax(UInt32)))
2147483647

The x86 has the similar problem, but the problem does not really arise because the conversion to UInt32 is via Int64 (#219 (comment)), and the conversion to Int32 is also via Int64.

FixedPointNumbers.jl/src/fixed.jl

Lines 105 to 108 in 9ca0d9d

	function rem(x::Real, ::Type{F}) where {T, f, F <: Fixed{T,f}}
	y = _unsafe_trunc(promote_type(Int64, T), round(x * @exp2(f)))
	reinterpret(F, _unsafe_trunc(T, y))
	end