Specialize sign-related functions

Author: kimikage

src/FixedPointNumbers.jl

@@ -6,6 +6,7 @@ import Base: ==, <, <=, -, +, *, /, ~, isapprox,
              zero, oneunit, one, typemin, typemax, floatmin, floatmax, eps, reinterpret,
              float, trunc, round, floor, ceil, bswap,
              div, fld, rem, mod, mod1, fld1, min, max, minmax,
+             signed, unsigned, copysign, flipsign, signbit,
              rand, length
 
 import Statistics   # for _mean_promote
@@ -46,6 +47,9 @@ reinterpret(::Type{X}, x::T) where {T <: Integer, X <: FixedPoint{T}} = X(x, 0)
 nbitsfrac(::Type{X}) where {T, f, X <: FixedPoint{T,f}} = f
 rawtype(::Type{X}) where {T, X <: FixedPoint{T}} = T
 
+# traits based on static parameters
+signbits(::Type{X}) where {T, X <: FixedPoint{T}} = T <: Unsigned ? 0 : 1
+
 # construction using the (approximate) intended value, i.e., N0f8
 *(x::Real, ::Type{X}) where {X <: FixedPoint} = _convert(X, x)
 
@@ -173,6 +177,30 @@ end
 
 bswap(x::X) where {X <: FixedPoint} = sizeof(X) == 1 ? x : X(bswap(x.i), 0)
 
+# Since `FixedPoint` is not an integer type, it is not clear in what type
+# `signed` and `unsigned` for `FixedPoint` should return values. They should
+# currently throw errors in case we support "unsigned Fixed" or "signed Normed"
+# in the future. The following "incomplete" code is necessary for Julia v1.0
+# etc. to prevent accidental conversion to an integer type.
+signed(x::X) where {X <: FixedPoint} = signed(X)(signed(x.i), 0)
+unsigned(x::X) where {X <: FixedPoint} = unsigned(X)(unsigned(x.i), 0)
+
+function copysign(x::X, y::Real) where {T, X <: FixedPoint{T}}
+    T <: Signed ? X(copysign(x.i, y), 0) : throw_not_a_signed_number_error(x)
+end
+function flipsign(x::X, y::Real) where {T, X <: FixedPoint{T}}
+    T <: Signed ? X(flipsign(x.i, y), 0) : throw_not_a_signed_number_error(x)
+end
+if copysign(-1, 0x1) !== 1 # for Julia v1.0 and v1.1 (julia #30748)
+    copysign(x::X, y::Unsigned) where {T, X <: FixedPoint{T}} = copysign(x, signed(y))
+    flipsign(x::X, y::Unsigned) where {T, X <: FixedPoint{T}} = flipsign(x, signed(y))
+end
+@noinline function throw_not_a_signed_number_error(x)
+    throw(ArgumentError("$x is not a signed number."))
+end
+
+signbit(x::X) where {X <: FixedPoint} = signbit(x.i)
+
 for f in (:zero, :oneunit, :one, :eps, :rawone, :rawtype, :floattype)
     @eval begin
         $f(x::FixedPoint) = $f(typeof(x))

src/fixed.jl

@@ -25,7 +25,6 @@ struct Fixed{T <: Signed, f} <: FixedPoint{T, f}
 end
 
 typechar(::Type{X}) where {X <: Fixed} = 'Q'
-signbits(::Type{X}) where {X <: Fixed} = 1
 
 for T in (Int8, Int16, Int32, Int64)
     io = IOBuffer()

src/normed.jl

@@ -20,7 +20,6 @@ struct Normed{T <: Unsigned, f} <: FixedPoint{T, f}
 end
 
 typechar(::Type{X}) where {X <: Normed} = 'N'
-signbits(::Type{X}) where {X <: Normed} = 0
 
 for T in (UInt8, UInt16, UInt32, UInt64)
     io = IOBuffer()
@@ -248,8 +247,6 @@ Base.BigFloat(x::Normed) = reinterpret(x)*(1/BigFloat(rawone(x)))
 
 Base.Rational(x::Normed) = reinterpret(x)//rawone(x)
 
-abs(x::Normed) = x
-
 # unchecked arithmetic
 *(x::T, y::T) where {T <: Normed} = convert(T,convert(floattype(T), x)*convert(floattype(T), y))
 /(x::T, y::T) where {T <: Normed} = convert(T,convert(floattype(T), x)/convert(floattype(T), y))

test/fixed.jl

@@ -399,6 +399,23 @@ end
     @test bswap(Q0f15(0.5)) === reinterpret(Q0f15, signed(0x0040))
 end
 
+@testset "sign-related functions" begin
+    @test_throws Exception signed(Q0f7)
+    @test_throws Exception signed(0.5Q0f7)
+    @test_throws Exception unsigned(Q0f7)
+    @test_throws Exception unsigned(0.5Q0f7)
+    @test copysign(0.5Q0f7, 0x1) === 0.5Q0f7
+    @test copysign(0.5Q0f7, -1) === -0.5Q0f7
+    @test flipsign(0.5Q0f7, 0x1) === 0.5Q0f7
+    @test flipsign(0.5Q0f7, -1) === -0.5Q0f7
+    @test_throws ArgumentError sign(0Q0f7)
+    @test sign(0Q1f6) === 0Q1f6
+    @test sign(0.5Q1f6) === 1Q1f6
+    @test sign(-0.5Q1f6) === -1Q1f6
+    @test signbit(0.5Q0f7) === false
+    @test signbit(-0.5Q0f7) === true
+end
+
 @testset "Promotion within Fixed" begin
     @test @inferred(promote(Q0f7(0.25), Q0f7(0.75))) ===
         (Q0f7(0.25), Q0f7(0.75))

test/normed.jl

@@ -318,6 +318,19 @@ end
     @test minmax(N0f8(0.8), N0f8(0.2)) === (N0f8(0.2), N0f8(0.8))
 end
 
+@testset "sign-related functions" begin
+    @test_throws Exception signed(N0f8)
+    @test_throws Exception signed(1N0f8)
+    @test_throws Exception unsigned(N0f8)
+    @test_throws Exception unsigned(1N0f8)
+    @test_throws ArgumentError copysign(1N0f8, 0x1)
+    @test_throws ArgumentError copysign(1N0f8, -1)
+    @test_throws ArgumentError flipsign(1N0f8, 0x1)
+    @test_throws ArgumentError flipsign(1N0f8, -1)
+    @test_throws ArgumentError sign(0N0f8)
+    @test signbit(1N0f8) === false
+end
+
 @testset "unit range" begin
     @test length(N0f8(0):N0f8(1)) == 2
     @test length(N0f8(1):N0f8(0)) == 0