Fixed Jacobians, added inplace function support to gradients, fixed all tests.

Author: dextorious

src/derivatives.jl

@@ -1,10 +1,10 @@
 #=
-Sinple-point derivatives of scalar->scalar maps.
+Single-point derivatives of scalar->scalar maps.
 =#
 function finite_difference_derivative(f, x::T, fdtype::DataType=Val{:central},
     returntype::DataType=eltype(x), f_x::Union{Void,T}=nothing) where T<:Number
 
-    epsilon = compute_epsilon(fdtype, real(x))
+    epsilon = compute_epsilon(fdtype, x)
     if fdtype==Val{:forward}
         return (f(x+epsilon) - f(x)) / epsilon
     elseif fdtype==Val{:central}
@@ -73,7 +73,7 @@ end
 function DerivativeCache(
     x          :: AbstractArray{<:Number},
     fx         :: Union{Void,AbstractArray{<:Number}} = nothing,
-    epsilon    :: Union{Void,AbstractArray{<:Number}} = nothing,
+    epsilon    :: Union{Void,AbstractArray{<:Real}} = nothing,
     fdtype     :: DataType = Val{:central},
     returntype :: DataType = eltype(x))
 
@@ -99,8 +99,8 @@ function DerivativeCache(
         if typeof(epsilon)==Void || eltype(epsilon)!=real(eltype(x))
             epsilon = zeros(real(eltype(x)), size(x))
         end
-        epsilon_factor = compute_epsilon_factor(fdtype, real(eltype(x)))
-        @. epsilon = compute_epsilon(fdtype, real(x), epsilon_factor)
+        epsilon_factor = compute_epsilon_factor(fdtype, eltype(x))
+        @. epsilon = compute_epsilon(fdtype, x, epsilon_factor)
         _epsilon = epsilon
     end
     DerivativeCache{typeof(_fx),typeof(_epsilon),fdtype,returntype}(_fx,_epsilon)
@@ -115,7 +115,7 @@ function finite_difference_derivative(
     fdtype     :: DataType = Val{:central},
     returntype :: DataType = eltype(x),      # return type of f
     fx         :: Union{Void,AbstractArray{<:Number}} = nothing,
-    epsilon    :: Union{Void,AbstractArray{<:Real}}   = nothing)
+    epsilon    :: Union{Void,AbstractArray{<:Real}} = nothing)
 
     df = zeros(returntype, size(x))
     finite_difference_derivative!(df, f, x, fdtype, returntype, fx, epsilon)
@@ -160,10 +160,10 @@ Optimized implementations for StridedArrays.
 Essentially, the only difference between these and the AbstractArray case
 is that here we can compute the epsilon one by one in local variables and avoid caching it.
 =#
-function _finite_difference_derivative!(df::StridedArray, f, x::StridedArray,
+function finite_difference_derivative!(df::StridedArray, f, x::StridedArray,
     cache::DerivativeCache{T1,T2,fdtype,returntype}) where {T1,T2,fdtype,returntype}
 
-    epsilon_factor = compute_epsilon_factor(fdtype, real(eltype(x)))
+    epsilon_factor = compute_epsilon_factor(fdtype, eltype(x))
     if fdtype == Val{:forward}
         fx = cache.fx
         @inbounds for i ∈ eachindex(x)

src/finitediff.jl

@@ -6,12 +6,12 @@ Very heavily inspired by Calculus.jl, but with an emphasis on performance and Di
 Compute the finite difference interval epsilon.
 Reference: Numerical Recipes, chapter 5.7.
 =#
-@inline function compute_epsilon(::Type{Val{:forward}}, x::T, eps_sqrt::T=sqrt(eps(T))) where T<:Real
-    eps_sqrt * max(one(T), abs(x))
+@inline function compute_epsilon(::Type{Val{:forward}}, x::T, eps_sqrt=sqrt(eps(real(T)))) where T<:Number
+    eps_sqrt * max(one(real(T)), abs(x))
 end
 
-@inline function compute_epsilon(::Type{Val{:central}}, x::T, eps_cbrt::T=cbrt(eps(T))) where T<:Real
-    eps_cbrt * max(one(T), abs(x))
+@inline function compute_epsilon(::Type{Val{:central}}, x::T, eps_cbrt=cbrt(eps(real(T)))) where T<:Number
+    eps_cbrt * max(one(real(T)), abs(x))
 end
 
 @inline function compute_epsilon(::Type{Val{:complex}}, x::T, ::Union{Void,T}=nothing) where T<:Real
@@ -20,20 +20,20 @@ end
 
 @inline function compute_epsilon_factor(fdtype::DataType, ::Type{T}) where T<:Number
     if fdtype==Val{:forward}
-        return sqrt(eps(T))
+        return sqrt(eps(real(T)))
     elseif fdtype==Val{:central}
-        return cbrt(eps(T))
+        return cbrt(eps(real(T)))
     else
-        return one(T)
+        return one(real(T))
     end
 end
 
-function fdtype_error(funtype::DataType=Val{:Real})
-    if funtype == Val{:Real}
+function fdtype_error(funtype::DataType=Float64)
+    if funtype<:Real
         error("Unrecognized fdtype: valid values are Val{:forward}, Val{:central} and Val{:complex}.")
-    elseif funtype == Val{:Complex}
+    elseif funtype<:Complex
         error("Unrecognized fdtype: valid values are Val{:forward} or Val{:central}.")
     else
-        error("Unrecognized funtype: valid values are Val{:Real} or Val{:Complex}.")
+        error("Unrecognized returntype: should be a subtype of Real or Complex.")
     end
 end