Improve consistency of arithmetic with Bool

Author: kimikage

src/ColorVectorSpace.jl

@@ -61,6 +61,19 @@ divtype(::Type{A}, ::Type{B}) where {A,B} = coltype(typeof(zero(A)/oneunit(B)))
 powtype(::Type{A}, ::Type{B}) where {A,B} = coltype(typeof(zero(A)^zero(B)))
 sumtype(a::Colorant, b::Colorant) = coltype(sumtype(eltype(a),eltype(b)))
 
+multype(::Type{Bool}, ::Type{B}) where {B} = B
+multype(::Type{A}, ::Type{Bool}) where {A} = A <: Integer ? multype(A, N0f8) : A
+multype(::Type{Bool}, ::Type{Bool}) = Bool
+sumtype(::Type{Bool}, ::Type{B}) where {B} = sumtype(B <: Integer ? N0f8 : UInt8, B)
+sumtype(::Type{A}, ::Type{Bool}) where {A} = sumtype(Bool, A)
+sumtype(::Type{Bool}, ::Type{Bool}) = Bool
+divtype(::Type{Bool}, ::Type{B}) where {B} = divtype(B <: Integer ? N0f8 : UInt8, B)
+divtype(::Type{A}, ::Type{Bool}) where {A} = divtype(A, N0f8)
+divtype(::Type{Bool}, ::Type{Bool}) = divtype(Bool, N0f8)
+powtype(::Type{Bool}, ::Type{B}) where {B} = B <: Integer ? Bool : B
+powtype(::Type{A}, ::Type{Bool}) where {A} = A
+powtype(::Type{Bool}, ::Type{Bool}) = Bool
+
 coltype(::Type{T}) where {T<:Fractional} = T
 coltype(::Type{T}) where {T<:Number}     = floattype(T)
 
@@ -140,12 +153,15 @@ dotc(x::Real, y::Real) = dotc(promote(x, y)...)
 ## Math on Colors. These implementations encourage inlining and,
 ## for the case of Normed types, nearly halve the number of multiplications (for RGB)
 
+_neg(x) = -x
+_neg(x::Bool) = x # GF(2)
+
 # Scalar RGB
 copy(c::AbstractRGB) = c
 (+)(c::AbstractRGB) = mapc(+, c)
 (+)(c::TransparentRGB) = mapc(+, c)
-(-)(c::AbstractRGB) = mapc(-, c)
-(-)(c::TransparentRGB) = mapc(-, c)
+(-)(c::AbstractRGB) = mapc(_neg, c)
+(-)(c::TransparentRGB) = mapc(_neg, c)
 (*)(f::Real, c::AbstractRGB) = arith_colorant_type(c){multype(typeof(f),eltype(c))}(f*red(c), f*green(c), f*blue(c))
 (*)(f::Real, c::TransparentRGB) = arith_colorant_type(c){multype(typeof(f),eltype(c))}(f*red(c), f*green(c), f*blue(c), f*alpha(c))
 function (*)(f::Real, c::AbstractRGB{T}) where T<:Normed
@@ -250,28 +266,42 @@ end
 (*)(f::Real, c::TransparentGray) = arith_colorant_type(c){multype(typeof(f),eltype(c))}(f*gray(c), f*alpha(c))
 (*)(c::AbstractGray, f::Real) = (*)(f, c)
 (*)(c::TransparentGray, f::Real) = (*)(f, c)
-(/)(c::AbstractGray, f::Real) = (one(f)/f)*c
-(/)(n::Number, c::AbstractGray) = base_color_type(c)(n/gray(c))
-(/)(c::TransparentGray, f::Real) = (one(f)/f)*c
-(/)(c::AbstractGray, f::Integer) = (one(eltype(c))/f)*c
+(/)(c::AbstractGray, f::Real) = (oneunit(divtype(eltype(c), typeof(f)))/f)*c
+(/)(c::AbstractGray{Bool}, f::Real) = arith_colorant_type(c){divtype(Bool,typeof(f))}(gray(c))/f
+(/)(n::Number, c::AbstractGray) = arith_colorant_type(c){divtype(typeof(real(n)),eltype(c))}(n/gray(c))
+(/)(c::TransparentGray, f::Real) = (oneunit(divtype(eltype(c), typeof(f)))/f)*c
 (/)(c::TransparentGray, f::Integer) = (one(eltype(c))/f)*c
 (+)(a::AbstractGray{S}, b::AbstractGray{T}) where {S,T} = parametric(color_rettype(a,b), sumtype(S,T))(gray(a)+gray(b))
+(+)(a::AbstractGray{Bool}, b::AbstractGray{T}) where {T} = parametric(color_rettype(a,b), sumtype(Bool,T))(gray(a)) + b
+(+)(a::AbstractGray{S}, b::AbstractGray{Bool}) where {S} = b + a
+(+)(a::AbstractGray{Bool}, b::AbstractGray{Bool}) = parametric(color_rettype(a,b), Bool)(gray(a) ⊻ gray(b))
 (+)(a::TransparentGray, b::TransparentGray) = parametric(color_rettype(a,b), sumtype(eltype(a),eltype(b)))(gray(a)+gray(b),alpha(a)+alpha(b))
 (-)(a::AbstractGray{S}, b::AbstractGray{T}) where {S,T} = parametric(color_rettype(a,b), sumtype(S,T))(gray(a)-gray(b))
+(-)(a::AbstractGray{Bool}, b::AbstractGray{T}) where {T} = parametric(color_rettype(a,b), sumtype(Bool,T))(gray(a)) - b
+(-)(a::AbstractGray{S}, b::AbstractGray{Bool}) where {S} = a - parametric(color_rettype(a,b), sumtype(S,Bool))(gray(b))
+(-)(a::AbstractGray{Bool}, b::AbstractGray{Bool}) = a + b # GF(2)
 (-)(a::TransparentGray, b::TransparentGray) = parametric(color_rettype(a,b), sumtype(eltype(a),eltype(b)))(gray(a)-gray(b),alpha(a)-alpha(b))
 (*)(a::AbstractGray{S}, b::AbstractGray{T}) where {S,T} = parametric(color_rettype(a,b), multype(S,T))(gray(a)*gray(b))
 (^)(a::AbstractGray{S}, b::Integer) where {S} = arith_colorant_type(a){powtype(S,Int)}(gray(a)^convert(Int,b))
 (^)(a::AbstractGray{S}, b::Real) where {S} = arith_colorant_type(a){powtype(S,typeof(b))}(gray(a)^b)
 (+)(c::AbstractGray) = c
 (+)(c::TransparentGray) = c
-(-)(c::AbstractGray) = typeof(c)(-gray(c))
-(-)(c::TransparentGray) = typeof(c)(-gray(c),-alpha(c))
+(-)(c::AbstractGray) = typeof(c)(_neg(gray(c)))
+(-)(c::TransparentGray) = typeof(c)(_neg(gray(c)),_neg(alpha(c)))
 (/)(a::C, b::C) where C<:AbstractGray = base_color_type(C)(gray(a)/gray(b))
 (/)(a::AbstractGray, b::AbstractGray) = /(promote(a, b)...)
+(/)(a::AbstractGray{Bool}, b::AbstractGray) = /(UInt8(gray(a)), b)
+(/)(a::AbstractGray{Bool}, b::AbstractGray{Bool}) = gray(b) ? a : throw(DivideError())
 (+)(a::AbstractGray, b::Number) = base_color_type(a)(gray(a)+b)
+(+)(a::AbstractGray{Bool}, b::Number) = arith_colorant_type(a){sumtype(Bool, typeof(b))}(gray(a)) + b
+(+)(a::AbstractGray{Bool}, b::Bool) = a + UInt8(b)
 (+)(a::Number, b::AbstractGray) = b+a
 (-)(a::AbstractGray, b::Number) = base_color_type(a)(gray(a)-b)
 (-)(a::Number, b::AbstractGray) = base_color_type(b)(a-gray(b))
+(-)(a::AbstractGray{Bool}, b::Number) = arith_colorant_type(a){sumtype(Bool, typeof(b))}(gray(a)) - b
+(-)(a::Number, b::AbstractGray{Bool}) = a - arith_colorant_type(b){sumtype(typeof(a), Bool)}(gray(b))
+(-)(a::AbstractGray{Bool}, b::Bool) = a - UInt8(b)
+(-)(a::Bool, b::AbstractGray{Bool}) = UInt8(a) - b
 
 (⋅)(x::AbstractGray, y::AbstractGray) = gray(x)*gray(y)
 (⊙)(x::C, y::C) where C<:AbstractGray = base_color_type(C)(gray(x)*gray(y))

test/runtests.jl

@@ -3,6 +3,8 @@ using ColorVectorSpace, Colors, FixedPointNumbers
 
 using Test
 
+@test isempty(detect_ambiguities(ColorVectorSpace))
+
 n8sum(x,y) = Float64(N0f8(x)) + Float64(N0f8(y))
 
 macro test_colortype_approx_eq(a, b)
@@ -480,6 +482,78 @@ ColorTypes.blue(c::RatRGB)  = c.b
         @test cf ⋅ cf   === (Float64(red(cf))^2 + Float64(green(cf))^2 + Float64(blue(cf))^2)/3
     end
 
+    @testset "arithmetic with Bool" begin # issue 148
+        cb = Gray{Bool}(1)
+        @test @inferred(+cb) === cb
+        @test @inferred(-cb) === cb # wrapped around
+        @test @inferred(one(cb)*cb) === cb
+        @test oneunit(cb) === Gray(true)
+        # vs. Bool
+        @test @inferred(cb + true) === @inferred(true + cb) === Gray{Float32}(2)
+        @test @inferred(cb - true) === Gray{Float32}(0)
+        @test @inferred(true - cb) === Gray{Float32}(0)
+        @test @inferred(cb * true) === @inferred(true * cb) === Gray{Bool}(1)
+        @test @inferred(cb / true) === Gray{Float32}(1)
+        @test @inferred(true / cb) === Gray{Float32}(1)
+        @test @inferred(cb^true) === cb
+        # vs. Gray{Bool}
+        @test @inferred(cb + Gray(true)) === @inferred(Gray(true) + cb) === Gray{Bool}(0) # wrapped around
+        @test @inferred(cb - Gray(true)) === Gray{Bool}(0)
+        @test @inferred(Gray(false) - cb) === Gray{Bool}(1) # wrapped around
+        @test @inferred(cb * Gray(true)) === @inferred(Gray(true) * cb) === Gray{Bool}(1)
+        @test @inferred(cb / Gray(true)) === Gray{Bool}(1)
+        @test_throws Exception cb / Gray(false)
+        # vs. Int
+        @test @inferred(cb + 2) === @inferred(2 + cb) === Gray{Float32}(3)
+        @test @inferred(cb - 2) === Gray{Float32}(-1)
+        @test @inferred(2 - cb) === Gray{Float32}(1)
+        @test @inferred(cb * 2) === @inferred(2 * cb) === Gray{Float32}(2)
+        @test @inferred(cb / 2) === Gray{Float32}(0.5)
+        @test @inferred(2 / cb) === Gray{Float32}(2)
+        @test @inferred(cb^1) === cb
+        # vs. Float32 and Gray{Float32}
+        @testset "vs. $(typeof(x))" for x in (0.5f0, Gray(0.5f0))
+            @test @inferred(cb + x) === @inferred(x + cb) === Gray{Float32}(1.5)
+            @test @inferred(cb - x) === Gray{Float32}(0.5)
+            @test @inferred(x - cb) === Gray{Float32}(-0.5)
+            @test @inferred(cb * x) === @inferred(x * cb) === Gray{Float32}(0.5)
+            @test @inferred(cb / x) === Gray{Float32}(2)
+            @test @inferred(x / cb) === Gray{Float32}(0.5)
+        end
+        @test @inferred(cb^0.5f0) === Gray{Float32}(1)
+        # vs. N0f8 and Gray{N0f8}
+        @testset "vs. $(typeof(x))" for x in (0.6N0f8, Gray(0.6N0f8))
+            @test @inferred(cb + x) === @inferred(x + cb) === Gray{Float32}(1.6)
+            @test @inferred(cb - x) === Gray{Float32}(1.0f0 - 0.6N0f8)
+            @test @inferred(x - cb) === Gray{Float32}(0.6N0f8 - 1.0f0)
+            @test @inferred(cb * x) === @inferred(x * cb) === Gray{N0f8}(0.6)
+            @test @inferred(cb / x) === Gray{Float32}(1 / 0.6)
+            @test @inferred(x / cb) === Gray{N0f8}(0.6)
+        end
+
+        @testset "vs. $(typeof(c)) multiplications" for c in (Gray(true), Gray(0.5f0), Gray(0.6N0f8))
+            @test @inferred(cb ⋅ c) === @inferred(c ⋅ cb) === gray(c)
+            @test @inferred(cb ⊙ c) === @inferred(c ⊙ cb) === c
+            @test @inferred(cb ⊗ c) === @inferred(c ⊗ cb) === c
+        end
+        cf = RGB{Float32}(0.1, 0.2, 0.3)
+        @test @inferred(cf + cb) === @inferred(cb + cf) === RGB{Float32}(1.1, 1.2, 1.3)
+        @test @inferred(cf - cb) === RGB{Float32}(-0.9, -0.8, -0.7)
+        @test @inferred(cb - cf) === RGB{Float32}(0.9, 0.8, 0.7)
+        cu = RGB{N0f8}(0.1, 0.2, 0.3)
+        @test @inferred(cu + cb) === @inferred(cb + cu) === mapc(v -> v + 1N0f8, cu) # wrapped around
+        @test @inferred(cu - cb) === mapc(v -> v - 1N0f8, cu) # wrapped around
+        @test @inferred(cb - cu) === mapc(v -> 1N0f8 - v, cu)
+        @testset "vs. $(typeof(c))" for c in (cf, cu)
+            @test @inferred(c * true) === @inferred(true * c) === c
+            @test @inferred(c / true) === c / 1
+            @test @inferred(cb ⋅ c) === @inferred(c ⋅ cb) === Gray(1) ⋅ c
+            @test @inferred(cb ⊙ c) === @inferred(c ⊙ cb) === c
+            @test @inferred(cb ⊗ c) === Gray(1) ⊗ c
+            @test @inferred(c ⊗ cb) === c ⊗ Gray(1)
+        end
+    end
+
     @testset "Complement" begin
         @test complement(Gray(0.2)) === Gray(0.8)
         @test complement(AGray(0.2f0, 0.7f0)) === AGray(0.8f0, 0.7f0)