Improve code coverage by removing source code and tests

Co-authored-by: "Shashi Gowda" <gowda@mit.edu>
Co-authored-by: "Yingbo Ma" <mayingbo5@gmail.com>

Author: YingboMa

src/dual_context.jl

@@ -30,14 +30,8 @@ end
 @inline _partials(::Any, x) = Zero()
 @inline _partials(::Tag{T}, d::Dual{Tag{T}}) where T = d.partials
 
-#=
-function Wirtinger(primal::Partials, conjugate::Union{Number,ChainRulesCore.AbstractDifferential})
-    return Partials(map(p->Wirtinger(p, conjugate), primal.values))
-end
-function Wirtinger(primal::Partials, conjugate::Partials)
-    return Partials(map((p, c)->Wirtinger(p, c), primal.values, conjugate.values))
-end
-=#
+Wirtinger(primal, conjugate) = Wirtinger.(primal, conjugate)
+
 @inline _values(S, xs) = map(x->_value(S, x), xs)
 @inline _partialss(S, xs) = map(x->_partials(S, x), xs)
 
@@ -77,7 +71,7 @@ end
 
     # call frule to see if there is a rule for this call:
     if ctx.metadata isa Tag
-        ctx1 = similarcontext(ctx, metadata=innertag(ctx.metadata))
+        ctx1 = similarcontext(ctx, metadata=oldertag(ctx.metadata))
 
         # we call frule with an older context because the Dual numbers may
         # themselves contain Dual numbers that were created in an older context
@@ -92,7 +86,7 @@ end
         # a closure which closes over a Dual number, hence we call
         # recurse. Recurse overdubs the calls inside `f` and not `f` itself
 
-        return Cassette.recurse(ctx, f, args...)
+        return Cassette.overdub(ctx, f, args...)
     else
         # this means there exists an frule for this specific call.
         # frule_result is then a tuple (val, pushforward) where val
@@ -108,7 +102,7 @@ end
         # we call it with the older context because the partials
         # might themselves be Duals from older contexts
         if ctx.metadata isa Tag
-            ctx1 = similarcontext(ctx, metadata=innertag(ctx.metadata))
+            ctx1 = similarcontext(ctx, metadata=oldertag(ctx.metadata))
             ∂s = overdub(ctx1, pushforward, Zero(), ps...)
         else
             ∂s = pushforward(Zero(), ps...)
@@ -119,10 +113,10 @@ end
         # a tuple, we handle both cases:
         return if ∂s isa Tuple
             map(val, ∂s) do v, ∂
-                Dual{typeof(tag)}(v, ∂)
+                Dual{Tag{T}}(v, ∂)
             end
         else
-            Dual{typeof(tag)}(val, ∂s)
+            Dual{Tag{T}}(val, ∂s)
         end
     end
 end
@@ -145,7 +139,7 @@ end
         end
         # none of the arguments have the same tag as the context
         # try with the parent context
-        ctx1 = similarcontext(ctx, metadata=innertag(ctx.metadata))
+        ctx1 = similarcontext(ctx, metadata=oldertag(ctx.metadata))
         return overdub(ctx1, f, args...)
     else
         # call ChainRules.frule to execute `f` and
@@ -156,14 +150,16 @@ end
 
 function dualrun(f, args...)
     ctx = dualcontext()
-    overdub(ctx, f, args...)
+    return overdub(ctx, f, args...)
 end
 
 const BINARY_PREDICATES = Symbol[:isequal, :isless, :<, :>, :(==), :(!=), :(<=), :(>=)]
 
 for pred in BINARY_PREDICATES
-    @eval begin
-        isinteresting(ctx::TaggedCtx, ::typeof($(pred)), x, y) = anydual(x, y)
-        alternative(ctx::TaggedCtx, ::typeof($(pred)), x, y) = overdub(ctx, () -> $pred(value(x), value(y)))
+    @eval function alternative(ctx::TaggedCtx, ::typeof($(pred)), x, y)
+        vx, vy = value(x), value(y)
+        return isinteresting(ctx, $pred, vx, vy) ?
+        alternative(ctx, $pred, vx, vy) :
+        $pred(vx, vy)
     end
 end

src/dualarray.jl

@@ -22,7 +22,7 @@ function Base.print_array(io::IO, da::DualArray)
     Base.println(io)
     for i=1:npartials(da)
         Base.printstyled(io,"Partials($i):\n", bold=false, color=3)
-        Base.print_array(ioc, partials.(da, i))
+        Base.print_array(ioc, getindex.(partials.(da), i))
         i !== npartials(da) && Base.println(io)
     end
     return nothing
@@ -100,8 +100,9 @@ Base.@propagate_inbounds function Base.setindex!(d::DualArray, dual, i::Int...)
     dd[ii] = value(dual)
 
     slice_len = length(d)
+    ps = partials(dual)
     for j = 1:npartials(d)
-        dd[j * slice_len + ii] = partials(dual, j)
+        dd[j * slice_len + ii] = ps[j]
     end
     return dual
 end

src/dualnumber.jl

@@ -21,8 +21,6 @@ Dual(::Number1, [1]) --> Dual(1, Partials([1,])) # fail Any
 
 const NANSAFE_MODE_ENABLED = false
 
-const AMBIGUOUS_TYPES = (AbstractFloat, Irrational, Integer, Rational, Real, RoundingMode)
-
 const UNARY_PREDICATES = Symbol[:isinf, :isnan, :isfinite, :iseven, :isodd, :isreal, :isinteger]
 
 const DEFAULT_CHUNK_THRESHOLD = 12
@@ -59,37 +57,11 @@ chunksize(::Chunk{N}) where {N} = N
 # Dual #
 ########
 
-"""
-    ForwardDiff2.can_dual(V::Type)
-
-Determines whether the type V is allowed as the scalar type in a
-Dual. By default, only `<:Real` types are allowed.
-"""
-can_dual(::Type{<:Real}) = true
-can_dual(::Type) = false
-
 struct Dual{T,V,P} <: Real
     value::V
     partials::P
 end
 
-##############
-# Exceptions #
-##############
-
-struct DualMismatchError{A,B} <: Exception
-    a::A
-    b::B
-end
-
-Base.showerror(io::IO, e::DualMismatchError{A,B}) where {A,B} =
-    print(io, "Cannot determine ordering of Dual tags $(e.a) and $(e.b)")
-
-@noinline function throw_cannot_dual(V::Type)
-    throw(ArgumentError("Cannot create a dual over scalar type $V." *
-        " If the type behaves as a scalar, define FowardDiff.can_dual."))
-end
-
 ################
 # Constructors #
 ################
@@ -98,48 +70,26 @@ end
 # intercept calls to dualtag
 dualtag() = nothing
 
-@inline function Dual{T}(value::V, partials::P) where {T,V,P}
-    Q = promote_type(bottomvaluetype(V), eltype(P))
-    partials′ = convert.(Q, partials)
-    Dual{T,V,typeof(partials′)}(value, partials′)
-end
+@inline Dual{T}(value::V, partials::P) where {T,V,P} = Dual{T,V,P}(value, partials)
+
 #@inline Dual{T}(value::V, ::Chunk{N}, p::Val{i}) where {T,V,P,i} = Dual{T}(value, single_seed(Partials{N,V}, p))
 @inline Dual(value, partials) = Dual{typeof(dualtag())}(value, partials)
 
-# we define these special cases so that the "constructor <--> convert" pun holds for `Dual`
-@inline Dual{T,V,P}(x::Dual{T,V,P}) where {T,V,P} = x
-@inline Dual{T,V,P}(x) where {T,V,P} = convert(Dual{T,V,P}, x)
-@inline Dual{T,V,P}(x::Number) where {T,V,P} = convert(Dual{T,V,P}, x)
-@inline Dual{T,V}(x) where {T,V} = convert(Dual{T,V}, x)
-
 ##############################
 # Utility/Accessor Functions #
 ##############################
 
-@inline bottomvaluetype(::Type{Dual{T,V,P}}) where {T,V,P} = bottomvaluetype(V)
-@inline bottomvaluetype(::Type{T}) where {T<:Any} = T
 @inline value(x) = x
 @inline value(d::Dual) = d.value
 
-@inline partials(d::Dual) = d.partials
-@inline Base.@propagate_inbounds partials(d::Dual, i) = d.partials[i]
-@inline Base.@propagate_inbounds partials(d::Dual, i, j) = partials(d, i).partials[j]
-@inline Base.@propagate_inbounds partials(d::Dual, i, j, k...) = partials(partials(d, i, j), k...)
-
-@inline npartials(d::Dual) = length(d.partials)
-
-@inline order(::Type{V}) where {V} = 0
-@inline order(::Type{Dual{T,V,P}}) where {T,V,P} = 1 + order(V)
-
 @inline valtype(::V) where {V} = V
 @inline valtype(::Type{V}) where {V} = V
 @inline valtype(::Dual{T,V}) where {T,V} = V
 @inline valtype(::Type{Dual{T,V,P}}) where {T,V,P} = V
 
-@inline tagtype(::V) where {V} = Nothing
-@inline tagtype(::Type{V}) where {V} = Nothing
-@inline tagtype(::Dual{T}) where {T} = T
-@inline tagtype(::Type{Dual{T,V,P}}) where {T,V,P} = T
+@inline partials(d::Dual) = d.partials
+
+@inline npartials(d::Dual) = (ps = d.partials) isa Wirtinger ? 1 : length(ps)
 
 #####################
 # Generic Functions #
@@ -152,16 +102,16 @@ Base.eps(::Type{D}) where {D<:Dual} = eps(valtype(D))
 
 Base.rtoldefault(::Type{D}) where {D<:Dual} = Base.rtoldefault(valtype(D))
 
-Base.floor(::Type{R}, d::Dual) where {R<:Real} = floor(R, value(d))
+Base.floor(::Type{R}, d::Dual) where {R<:Number} = floor(R, value(d))
 Base.floor(d::Dual) = floor(value(d))
 
-Base.ceil(::Type{R}, d::Dual) where {R<:Real} = ceil(R, value(d))
+Base.ceil(::Type{R}, d::Dual) where {R<:Number} = ceil(R, value(d))
 Base.ceil(d::Dual) = ceil(value(d))
 
-Base.trunc(::Type{R}, d::Dual) where {R<:Real} = trunc(R, value(d))
+Base.trunc(::Type{R}, d::Dual) where {R<:Number} = trunc(R, value(d))
 Base.trunc(d::Dual) = trunc(value(d))
 
-Base.round(::Type{R}, d::Dual) where {R<:Real} = round(R, value(d))
+Base.round(::Type{R}, d::Dual) where {R<:Number} = round(R, value(d))
 Base.round(d::Dual) = round(value(d))
 
 Base.hash(d::Dual) = hash(value(d))
@@ -205,49 +155,11 @@ end
 # Promotion/Conversion #
 ########################
 
-function Base.promote_rule(::Type{Dual{T1,V1,P1}},
-                           ::Type{Dual{T2,V2,P2}}) where {T1,V1,P1,T2,V2,P2}
-    # V1 and V2 might themselves be Dual types
-    if T2 ≺ T1
-        Dual{T1,promote_type(V1,Dual{T2,V2,P2}),P1}
-    else
-        Dual{T2,promote_type(V2,Dual{T1,V1,P1}),P2}
-    end
-end
-
-function Base.promote_rule(::Type{Dual{T,A,P}},
-                           ::Type{Dual{T,B,P}}) where {T,A,B,P}
-    return Dual{T,promote_type(A, B),P}
-end
-
-for R in (Irrational, Real, BigFloat, Bool)
-    if isconcretetype(R) # issue #322
-        @eval begin
-            Base.promote_rule(::Type{$R}, ::Type{Dual{T,V,P}}) where {T,V,P} = Dual{T,promote_type($R, V),P}
-            Base.promote_rule(::Type{Dual{T,V,P}}, ::Type{$R}) where {T,V,P} = Dual{T,promote_type(V, $R),P}
-        end
-    else
-        @eval begin
-            Base.promote_rule(::Type{R}, ::Type{Dual{T,V,P}}) where {R<:$R,T,V,P} = Dual{T,promote_type(R, V),P}
-            Base.promote_rule(::Type{Dual{T,V,P}}, ::Type{R}) where {T,V,P,R<:$R} = Dual{T,promote_type(V, R),P}
-        end
-    end
-end
-
 Base.convert(::Type{Dual{T,V,P}}, d::Dual{T}) where {T,V,P} = Dual{T}(convert(V, value(d)), convert(P, partials(d)))
 Base.convert(::Type{Dual{T,V,P}}, x) where {T,V,P} = Dual{T}(convert(V, x), zero(P))
 Base.convert(::Type{Dual{T,V,P}}, x::Number) where {T,V,P} = Dual{T}(convert(V, x), zero(P))
 Base.convert(::Type{D}, d::D) where {D<:Dual} = d
 
-Base.float(d::Dual{T}) where {T} = Dual{T}(value(d), map(float, partials(d)))
-Base.AbstractFloat(d::Dual{T}) where {T} = Dual{T}(convert(AbstractFloat, value(d)), map(x->convert(AbstractFloat, x), partials(d)))
-
-###################################
-# General Mathematical Operations #
-###################################
-
-@inline Base.conj(d::Dual) = d
-
 ###################
 # Pretty Printing #
 ###################
@@ -258,7 +170,7 @@ function tag_show(t, n=0)
     if t isa Nothing
         return subscript_num(n)
     elseif t isa Tag
-        tag_show(innertag(t), n+1)
+        tag_show(oldertag(t), n+1)
     else
         return "{" * repr(t) * "}" * subscript_num(n)
     end

src/tag.jl

@@ -4,8 +4,8 @@ struct Tag{Parent} end
 @inline _find_dual(tag::T, l, i, x::Dual{T}, xs...) where {T} = i
 @inline _find_dual(tag::T, l, i, x, xs...) where {T} = _find_dual(tag, l, i+1, xs...)
 
-@inline innertag(::Tag{Tag{T}}) where T = Tag{T}()
-@inline innertag(::Tag{T}) where T = nothing
+@inline oldertag(::Tag{Tag{T}}) where T = Tag{T}()
+@inline oldertag(::Tag{T}) where T = nothing
 
 @inline function find_dual(T::TT, xs...) where {TT<:Tag}
     _find_dual(T, length(xs), 1, xs...)

test/dualarray.jl

@@ -17,7 +17,7 @@ using StaticArrays: SVector
         dx .= sin.(x)
         @test_broken sin.(x) == dx
         @test sin.(_x) == value.(dx)
-        @test cos.(_x) == partials.(dx, 1)
+        @test cos.(_x) == first.(partials.(dx))
     end
 end