reconstruct Complex from Tangent, do we need this?

Author: mcabbott

src/differentials/abstract_zero.jl

@@ -25,6 +25,10 @@ Base.transpose(z::AbstractZero) = z
 Base.:/(z::AbstractZero, ::Any) = z
 
 Base.convert(::Type{T}, x::AbstractZero) where T <: Number = zero(T)
+(::Type{T})(xs::AbstractZero...) where T <: Number = zero(T)
+
+(::Type{Complex})(x::AbstractZero, y::Real) = Complex(false, y)
+(::Type{Complex})(x::Real, y::AbstractZero) = Complex(x, false)
 
 Base.getindex(z::AbstractZero, k) = z
 

src/projection.jl

@@ -173,6 +173,11 @@ end
 (project::ProjectTo{<:Real})(dx::Complex) = project(real(dx))
 (project::ProjectTo{<:Complex})(dx::Real) = project(complex(dx))
 
+# Tangents: we prefer to reconstruct numbers, but only safe to try when their constructor
+# understands, including a mix of Zeros & reals. Other cases, we just let through:
+(project::ProjectTo{<:Complex})(dx::Tangent{<:Number}) = project(Complex(dx.re, dx.im))
+(::ProjectTo{<:Number})(dx::Tangent{<:Number}) = dx
+
 # Arrays
 # If we don't have a more specialized `ProjectTo` rule, we just assume that there is
 # no structure worth re-imposing. Then any array is acceptable as a gradient.

test/differentials/abstract_zero.jl

@@ -64,9 +64,15 @@
         @test complex(z, z) === z
         @test complex(z, 2.0) === Complex{Float64}(0.0, 2.0)
         @test complex(1.5, z) === Complex{Float64}(1.5, 0.0)
+        @test Complex(z, 2.0) === Complex{Float64}(0.0, 2.0)
+        @test Complex(1.5, z) === Complex{Float64}(1.5, 0.0)
+        @test ComplexF64(z, 2.0) === Complex{Float64}(0.0, 2.0)
+        @test ComplexF64(1.5, z) === Complex{Float64}(1.5, 0.0)
 
-        @test convert(Int64, ZeroTangent()) == 0
-        @test convert(Float64, ZeroTangent()) == 0.0
+        @test convert(Bool, ZeroTangent()) === false
+        @test convert(Int64, ZeroTangent()) === 0
+        @test convert(Float32, ZeroTangent()) === 0.0f0
+        @test convert(ComplexF64, ZeroTangent()) === 0.0 + 0.0im
     end
 
     @testset "NoTangent" begin

test/projection.jl

@@ -33,6 +33,9 @@ Base.zero(x::Dual) = Dual(zero(x.value), zero(x.partial))
         @test ProjectTo(1.0f0 + 2im)(3) === 3.0f0 + 0im
         @test ProjectTo(big(1.0))(2) === 2
         @test ProjectTo(1.0)(2) === 2.0
+
+        # Tangents
+        ProjectTo(1.0f0 + 2im)(Tangent{ComplexF64}(re=1, im=NoTangent())) === 1.0f0 + 0.0f0im
     end
 
     @testset "Dual" begin # some weird Real subtype that we should basically leave alone