Specialize sign-related functions

Author: kimikage

src/FixedPointNumbers.jl

@@ -6,6 +6,7 @@ import Base: ==, <, <=, -, +, *, /, ~, isapprox,
              zero, oneunit, one, typemin, typemax, floatmin, floatmax, eps, sizeof, reinterpret,
              float, trunc, round, floor, ceil, bswap,
              div, fld, rem, mod, mod1, fld1, min, max, minmax,
+             signed, unsigned, copysign, flipsign, signbit,
              rand, length
 
 using Base.Checked: checked_add, checked_sub, checked_div
@@ -171,6 +172,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/normed.jl

@@ -248,8 +248,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

@@ -397,6 +397,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