get all tests passing except for deprecation layer + SIMD tests

Author: jrevels

src/ForwardDiff.jl

@@ -52,7 +52,7 @@ include("derivative.jl")
 include("gradient.jl")
 include("jacobian.jl")
 include("hessian.jl")
-include("deprecated.jl")
+# include("deprecated.jl")
 
 export DiffBase
 

src/config.jl

@@ -31,8 +31,8 @@ end
 
 @compat immutable Tag{F,M} end
 
-Base.@pure order{V}(::Type{V}) = 0
-Base.@pure order{T,V,N}(::Type{Dual{T,V,N}}) = 1 + order(V)
+@inline order{V}(::Type{V}) = 0
+@inline order{T,V,N}(::Type{Dual{T,V,N}}) = 1 + order(V)
 
 ##################
 # AbstractConfig #
@@ -47,16 +47,16 @@ end
 
 function Base.showerror{F,G}(io::IO, e::ConfigMismatchError{F,G})
     print(io, "The provided configuration (of type $(typeof(e.cfg))) was constructed for a",
-              " function ($G), not the current target function ($F). ForwardDiff cannot safely",
+              " function other than the current target function. ForwardDiff cannot safely",
               " perform differentiation in this context; see the following issue for details:",
               " https://github.com/JuliaDiff/ForwardDiff.jl/issues/83. You can resolve this",
               " problem by constructing and using a configuration with the appropriate target",
-              " function, e.g. `ForwardDiff.GradientConfig($f, x)`")
+              " function, e.g. `ForwardDiff.GradientConfig($(e.f), x)`")
 end
 
 Base.copy(cfg::AbstractConfig) = deepcopy(cfg)
 
-@inline chunksize(::AbstractConfig{T,N}) = N
+@inline chunksize{T,N}(::AbstractConfig{T,N}) = N
 
 ##################
 # GradientConfig #
@@ -110,26 +110,26 @@ end
 # HessianConfig #
 #################
 
-@compat immutable HessianConfig{T,V,N,D,TJ,DJ} <: AbstractConfig{T,N}
-    jacobian_config::JacobianConfig{TJ,V,N,DJ}
-    gradient_config::GradientConfig{T,Dual{T,V,N},D}
+@compat immutable HessianConfig{T,V,N,D,MJ,DJ} <: AbstractConfig{T,N}
+    jacobian_config::JacobianConfig{Tag{Void,MJ},V,N,DJ}
+    gradient_config::GradientConfig{T,Dual{Tag{Void,MJ},V,N},D}
 end
 
 function HessianConfig{F,V}(f::F,
                             x::AbstractArray{V},
                             chunk::Chunk = Chunk(x),
-                            tag::Tag = Tag{F,order(V)}())
-    jacobian_config = JacobianConfig(f, x, chunk, tag)
-    gradient_config = GradientConfig(f, jacobian_config.duals, chunk)
+                            tag::Tag = Tag{F,order(Dual{Void,V,0})}())
+    jacobian_config = JacobianConfig(nothing, x, chunk)
+    gradient_config = GradientConfig(f, jacobian_config.duals, chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)
 end
 
 function HessianConfig{F,V}(result::DiffResult,
                             f::F,
                             x::AbstractArray{V},
                             chunk::Chunk = Chunk(x),
-                            tag::Tag = Tag{F,order(V)}())
-    jacobian_config = JacobianConfig(f, DiffBase.gradient(result), x, chunk, tag)
-    gradient_config = GradientConfig(f, jacobian_config.duals[2], chunk)
+                            tag::Tag = Tag{F,order(Dual{Void,V,0})}())
+    jacobian_config = JacobianConfig(nothing, DiffBase.gradient(result), x, chunk)
+    gradient_config = GradientConfig(f, jacobian_config.duals[2], chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)
 end

src/derivative.jl

@@ -2,26 +2,44 @@
 # API methods #
 ###############
 
-derivative{F}(f::F, x::Real) = extract_derivative(f(Dual(x, one(x))))
+@generated function derivative{F,R<:Real}(f::F, x::R)
+    T = Tag{F,order(R)}
+    return quote
+        $(Expr(:meta, :inline))
+        return extract_derivative(f(Dual{$T}(x, one(x))))
+    end
+end
 
 @generated function derivative{F,N}(f::F, x::NTuple{N,Real})
-    args = [:(Dual(x[$i], Val{N}, Val{$i})) for i in 1:N]
-    return :(extract_derivative(f($(args...))))
+    T = Tag{F,maximum(order(R) for R in x.parameters)}
+    args = [:(Dual{$T}(x[$i], Val{N}, Val{$i})) for i in 1:N]
+    return quote
+        $(Expr(:meta, :inline))
+        extract_derivative(f($(args...)))
+    end
 end
 
-function derivative!{F}(out, f::F, x::Real)
-    y = f(Dual(x, one(x)))
-    extract_derivative!(out, y)
-    return out
+@generated function derivative!{F,R<:Real}(out, f::F, x::R)
+    T = Tag{F,order(R)}
+    return quote
+        $(Expr(:meta, :inline))
+        extract_derivative!(out, f(Dual{$T}(x, one(x))))
+        return out
+    end
 end
 
 #####################
 # result extraction #
 #####################
 
-@generated extract_derivative{N}(y::Dual{N}) = Expr(:tuple, [:(partials(y, $i)) for i in 1:N]...)
+@generated function extract_derivative{T,V,N}(y::Dual{T,V,N})
+    return quote
+        $(Expr(:meta, :inline))
+        $(Expr(:tuple, [:(partials(y, $i)) for i in 1:N]...))
+    end
+end
 
-@inline extract_derivative(y::Dual{1}) = partials(y, 1)
+@inline extract_derivative{T,V}(y::Dual{T,V,1}) = partials(y, 1)
 @inline extract_derivative(y::Real) = zero(y)
 @inline extract_derivative(y::AbstractArray) = extract_derivative!(similar(y, valtype(eltype(y))), y)
 

src/dual.jl

@@ -18,9 +18,9 @@ end
 
 function Base.showerror{X,Y}(io::IO, e::TagMismatchError{X,Y})
     print(io, "potential perturbation confusion detected when computing binary operation ",
-              "on $(e.x) and $(e.y) (tag $X != tag $Y). ForwardDiff cannot safely perform ",
-              "differentiation in this context; see the following issue for details: ",
-              "https://github.com/JuliaDiff/ForwardDiff.jl/issues/83")
+              "on $(e.x) and $(e.y) (tag mismatch: $X != $Y). ForwardDiff cannot safely ",
+              "perform differentiation in this context; see the following issue for ",
+              "details: https://github.com/JuliaDiff/ForwardDiff.jl/issues/83")
 end
 
 ################
@@ -200,7 +200,7 @@ Base.AbstractFloat{T,V,N}(d::Dual{T,V,N}) = Dual{T,promote_type(V, Float16),N}(d
     Dual{T}(x - value(y), -partials(y))
 )
 
-@inline Base.:-(d::Dual) = Dual(-value(d), -partials(d))
+@inline Base.:-{T}(d::Dual{T}) = Dual{T}(-value(d), -partials(d))
 
 # Multiplication #
 #----------------#
@@ -338,6 +338,8 @@ end
 # Other Functions #
 #-----------------#
 
+# hypot
+
 @inline function calc_hypot{T}(x, y, ::Type{T})
     vx = value(x)
     vy = value(y)
@@ -352,12 +354,7 @@ end
     calc_hypot(x, y, T)
 )
 
-@inline sincos(x) = (sin(x), cos(x))
-
-@inline function sincos{T}(d::Dual{T})
-    sd, cd = sincos(value(d))
-    return (Dual{T}(sd, cd * partials(d)), Dual{T}(cd, -sd * partials(d)))
-end
+# atan2
 
 @inline function calc_atan2{T}(y, x, ::Type{T})
     z = y / x
@@ -374,36 +371,13 @@ end
     calc_atan2(x, y, T)
 )
 
-@inline function Base.fma(x::Dual, y::Dual, z::Dual)
-    vx, vy = value(x), value(y)
-    result = fma(vx, vy, value(z))
-    return Dual(result,
-                _mul_partials(partials(x), partials(y), vx, vy) + partials(z))
-end
+# sincos
 
-@inline function Base.fma(x::Dual, y::Dual, z::Real)
-    vx, vy = value(x), value(y)
-    result = fma(vx, vy, z)
-    return Dual(result, _mul_partials(partials(x), partials(y), vx, vy))
-end
-
-@inline function Base.fma(x::Dual, y::Real, z::Dual)
-    vx = value(x)
-    result = fma(vx, y, value(z))
-    return Dual(result, partials(x) * y + partials(z))
-end
-
-@inline Base.fma(x::Real, y::Dual, z::Dual) = fma(y, x, z)
-
-@inline function Base.fma(x::Dual, y::Real, z::Real)
-    vx = value(x)
-    return Dual(fma(vx, y, value(z)), partials(x) * y)
-end
-
-@inline Base.fma(x::Real, y::Dual, z::Real) = fma(y, x, z)
+@inline sincos(x) = (sin(x), cos(x))
 
-@inline function Base.fma(x::Real, y::Real, z::Dual)
-    Dual(fma(x, y, value(z)), partials(z))
+@inline function sincos{T}(d::Dual{T})
+    sd, cd = sincos(value(d))
+    return (Dual{T}(sd, cd * partials(d)), Dual{T}(cd, -sd * partials(d)))
 end
 
 ###################

src/gradient.jl

@@ -2,15 +2,20 @@
 # API methods #
 ###############
 
-function gradient{F}(f::F, x, cfg::AbstractConfig = GradientConfig(x))
+@compat const AllowedGradientConfig{F,M} = Union{GradientConfig{Tag{F,M}}, GradientConfig{Tag{Void,M}}}
+
+gradient(f, x, cfg::GradientConfig) = throw(ConfigMismatchError(f, cfg))
+gradient!(out, f, x, cfg::GradientConfig) = throw(ConfigMismatchError(f, cfg))
+
+function gradient{F,M}(f::F, x, cfg::AllowedGradientConfig{F,M} = GradientConfig(f, x))
     if chunksize(cfg) == length(x)
         return vector_mode_gradient(f, x, cfg)
     else
         return chunk_mode_gradient(f, x, cfg)
     end
 end
 
-function gradient!{F}(out, f::F, x, cfg::AbstractConfig = GradientConfig(x))
+function gradient!{F,M}(out, f::F, x, cfg::AllowedGradientConfig{F,M} = GradientConfig(f, x))
     if chunksize(cfg) == length(x)
         vector_mode_gradient!(out, f, x, cfg)
     else
@@ -72,9 +77,6 @@ end
 # chunk mode #
 ##############
 
-# single threaded #
-#-----------------#
-
 function chunk_mode_gradient_expr(out_definition::Expr)
     return quote
         @assert length(x) >= N "chunk size cannot be greater than length(x) ($(N) > $(length(x)))"
@@ -119,80 +121,10 @@ function chunk_mode_gradient_expr(out_definition::Expr)
     end
 end
 
-@eval function chunk_mode_gradient{F,N}(f::F, x, cfg::GradientConfig{N})
+@eval function chunk_mode_gradient{F,T,V,N}(f::F, x, cfg::GradientConfig{T,V,N})
     $(chunk_mode_gradient_expr(:(out = similar(x, valtype(ydual)))))
 end
 
-@eval function chunk_mode_gradient!{F,N}(out, f::F, x, cfg::GradientConfig{N})
+@eval function chunk_mode_gradient!{F,T,V,N}(out, f::F, x, cfg::GradientConfig{T,V,N})
     $(chunk_mode_gradient_expr(:()))
 end
-
-# multithreaded #
-#---------------#
-
-if IS_MULTITHREADED_JULIA
-    function multithread_chunk_mode_expr(out_definition::Expr)
-        return quote
-            cfg = gradient_config(multi_cfg)
-            N = chunksize(cfg)
-            @assert length(x) >= N "chunk size cannot be greater than length(x) ($(N) > $(length(x)))"
-
-            # precalculate loop bounds
-            xlen = length(x)
-            remainder = xlen % N
-            lastchunksize = ifelse(remainder == 0, N, remainder)
-            lastchunkindex = xlen - lastchunksize + 1
-            middlechunks = 2:div(xlen - lastchunksize, N)
-
-            # fetch and seed work vectors
-            current_cfg = cfg[compat_threadid()]
-            current_xdual = current_cfg.duals
-            current_seeds = current_cfg.seeds
-
-            Base.Threads.@threads for t in 1:length(cfg)
-                seed!(cfg[t].duals, x)
-            end
-
-            # do first chunk manually to calculate output type
-            seed!(current_xdual, x, 1, current_seeds)
-            current_ydual = f(current_xdual)
-            $(out_definition)
-            extract_gradient_chunk!(out, current_ydual, 1, N)
-            seed!(current_xdual, x, 1)
-
-            # do middle chunks
-            Base.Threads.@threads for c in middlechunks
-                # see https://github.com/JuliaLang/julia/issues/14948
-                local chunk_cfg = cfg[compat_threadid()]
-                local chunk_xdual = chunk_cfg.duals
-                local chunk_seeds = chunk_cfg.seeds
-                local chunk_index = ((c - 1) * N + 1)
-                seed!(chunk_xdual, x, chunk_index, chunk_seeds)
-                local chunk_dual = f(chunk_xdual)
-                extract_gradient_chunk!(out, chunk_dual, chunk_index, N)
-                seed!(chunk_xdual, x, chunk_index)
-            end
-
-            # do final chunk
-            seed!(current_xdual, x, lastchunkindex, current_seeds, lastchunksize)
-            current_ydual = f(current_xdual)
-            extract_gradient_chunk!(out, current_ydual, lastchunkindex, lastchunksize)
-
-            # load value, this is a no-op unless `out` is a DiffResult
-            extract_value!(out, current_ydual)
-
-            return out
-        end
-    end
-
-    @eval function chunk_mode_gradient{F}(f::F, x, multi_cfg::MultithreadConfig)
-        $(multithread_chunk_mode_expr(:(out = similar(x, valtype(current_ydual)))))
-    end
-
-    @eval function chunk_mode_gradient!{F}(out, f::F, x, multi_cfg::MultithreadConfig)
-        $(multithread_chunk_mode_expr(:()))
-    end
-else
-    chunk_mode_gradient(f, x, cfg::Tuple) = error("Multithreading is not enabled for this Julia installation.")
-    chunk_mode_gradient!(out, f, x, cfg::Tuple) = chunk_mode_gradient!(f, x, cfg)
-end

src/hessian.jl

@@ -2,24 +2,30 @@
 # API methods #
 ###############
 
-function hessian{F}(f::F, x, cfg::AbstractConfig = HessianConfig(x))
-    ∇f = y -> gradient(f, y, gradient_config(cfg))
-    return jacobian(∇f, x, jacobian_config(cfg))
+@compat const AllowedHessianConfig{F,M} = Union{HessianConfig{Tag{F,M}}, HessianConfig{Tag{Void,M}}}
+
+hessian(f, x, cfg::HessianConfig) = throw(ConfigMismatchError(f, cfg))
+hessian!(out, f, x, cfg::HessianConfig) = throw(ConfigMismatchError(f, cfg))
+hessian!(out::DiffResult, f, x, cfg::HessianConfig) = throw(ConfigMismatchError(f, cfg))
+
+function hessian{F,M}(f::F, x, cfg::AllowedHessianConfig{F,M} = HessianConfig(f, x))
+    ∇f = y -> gradient(f, y, cfg.gradient_config)
+    return jacobian(∇f, x, cfg.jacobian_config)
 end
 
-function hessian!{F}(out, f::F, x, cfg::AbstractConfig = HessianConfig(x))
-    ∇f = y -> gradient(f, y, gradient_config(cfg))
-    jacobian!(out, ∇f, x, jacobian_config(cfg))
+function hessian!{F,M}(out, f::F, x, cfg::AllowedHessianConfig{F,M} = HessianConfig(f, x))
+    ∇f = y -> gradient(f, y, cfg.gradient_config)
+    jacobian!(out, ∇f, x, cfg.jacobian_config)
     return out
 end
 
-function hessian!{F}(out::DiffResult, f::F, x, cfg::AbstractConfig = HessianConfig(out, x))
+function hessian!{F,M}(out::DiffResult, f::F, x, cfg::AllowedHessianConfig{F,M} = HessianConfig(out, f, x))
     ∇f! = (y, z) -> begin
         result = DiffResult(zero(eltype(y)), y)
-        gradient!(result, f, z, gradient_config(cfg))
+        gradient!(result, f, z, cfg.gradient_config)
         DiffBase.value!(out, value(DiffBase.value(result)))
         return y
     end
-    jacobian!(DiffBase.hessian(out), ∇f!, DiffBase.gradient(out), x, jacobian_config(cfg))
+    jacobian!(DiffBase.hessian(out), ∇f!, DiffBase.gradient(out), x, cfg.jacobian_config)
     return out
 end