add eltype for AbstractConfig (#222)

Author: jrevels

src/config.jl

@@ -40,6 +40,8 @@ end
 
 Base.copy(cfg::AbstractConfig) = deepcopy(cfg)
 
+Base.eltype(cfg::AbstractConfig) = eltype(typeof(cfg))
+
 @inline chunksize(::AbstractConfig{T,N}) where {T,N} = N
 
 ##################
@@ -60,6 +62,8 @@ function GradientConfig(::F,
     return GradientConfig{T,V,N,typeof(duals)}(seeds, duals)
 end
 
+Base.eltype(::Type{GradientConfig{T,V,N,D}}) where {T,V,N,D} = Dual{T,V,N}
+
 ##################
 # JacobianConfig #
 ##################
@@ -90,13 +94,15 @@ function JacobianConfig(::F,
     return JacobianConfig{T,X,N,typeof(duals)}(seeds, duals)
 end
 
+Base.eltype(::Type{JacobianConfig{T,V,N,D}}) where {T,V,N,D} = Dual{T,V,N}
+
 #################
 # HessianConfig #
 #################
 
 struct HessianConfig{T,V,N,D,H,DJ} <: AbstractConfig{T,N}
     jacobian_config::JacobianConfig{Tag{Void,H},V,N,DJ}
-    gradient_config::GradientConfig{T,Dual{Tag{Void,H},V,N},D}
+    gradient_config::GradientConfig{T,Dual{Tag{Void,H},V,N},N,D}
 end
 
 function HessianConfig(f::F,
@@ -117,3 +123,5 @@ function HessianConfig(f::F,
     gradient_config = GradientConfig(f, jacobian_config.duals[2], chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)
 end
+
+Base.eltype(::Type{HessianConfig{T,V,N,D,H,DJ}}) where {T,V,N,D,H,DJ} = Dual{T,Dual{Tag{Void,H},V,N},N}

test/GradientTest.jl

@@ -4,6 +4,7 @@ import Calculus
 
 using Base.Test
 using ForwardDiff
+using ForwardDiff: Dual, Tag
 using StaticArrays
 
 include(joinpath(dirname(@__FILE__), "utils.jl"))
@@ -21,6 +22,8 @@ for c in (1, 2, 3), tag in (nothing, f)
     println("  ...running hardcoded test with chunk size = $c and tag = $tag")
     cfg = ForwardDiff.GradientConfig(tag, x, ForwardDiff.Chunk{c}())
 
+    @test eltype(cfg) == Dual{typeof(Tag(typeof(tag), eltype(x))), eltype(x), c}
+
     @test isapprox(g, ForwardDiff.gradient(f, x, cfg))
     @test isapprox(g, ForwardDiff.gradient(f, x))
 

test/HessianTest.jl

@@ -4,6 +4,7 @@ import Calculus
 
 using Base.Test
 using ForwardDiff
+using ForwardDiff: Dual, Tag
 using StaticArrays
 
 include(joinpath(dirname(@__FILE__), "utils.jl"))
@@ -25,6 +26,10 @@ for c in (1, 2, 3), tag in (nothing, f)
     cfg = ForwardDiff.HessianConfig(tag, x, ForwardDiff.Chunk{c}())
     resultcfg = ForwardDiff.HessianConfig(tag, DiffBase.HessianResult(x), x, ForwardDiff.Chunk{c}())
 
+    D = Dual{typeof(Tag(Void, eltype(x))), eltype(x), c}
+    @test eltype(cfg) == Dual{typeof(Tag(typeof(tag), Dual{Void,eltype(x),0})), D, c}
+    @test eltype(resultcfg) == eltype(cfg)
+
     @test isapprox(h, ForwardDiff.hessian(f, x))
     @test isapprox(h, ForwardDiff.hessian(f, x, cfg))
 

test/JacobianTest.jl

@@ -4,7 +4,7 @@ import Calculus
 
 using Base.Test
 using ForwardDiff
-using ForwardDiff: JacobianConfig
+using ForwardDiff: Dual, Tag, JacobianConfig
 using StaticArrays
 
 include(joinpath(dirname(@__FILE__), "utils.jl"))
@@ -34,6 +34,9 @@ for c in (1, 2, 3), tags in ((nothing, nothing), (f, f!))
     cfg = JacobianConfig(tags[1], x, ForwardDiff.Chunk{c}())
     ycfg = JacobianConfig(tags[2], zeros(4), x, ForwardDiff.Chunk{c}())
 
+    @test eltype(cfg)  == Dual{typeof(Tag(typeof(tags[1]), eltype(x))), eltype(x), c}
+    @test eltype(ycfg) == Dual{typeof(Tag(typeof(tags[2]), eltype(x))), eltype(x), c}
+
     # testing f(x)
     @test isapprox(j, ForwardDiff.jacobian(f, x, cfg))
     @test isapprox(j, ForwardDiff.jacobian(f, x))