Merge pull request #100 from JuliaDiff/myb/fix

Remove unnecessary type constraints

Author: YingboMa

Project.toml

@@ -1,6 +1,6 @@
 name = "FiniteDiff"
 uuid = "6a86dc24-6348-571c-b903-95158fe2bd41"
-version = "2.3.1"
+version = "2.3.2"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"

src/derivatives.jl

@@ -4,12 +4,12 @@ Single-point derivatives of scalar->scalar maps.
 function finite_difference_derivative(
     f,
     x::T,
-    fdtype::Type{T1}=Val{:central},
-    returntype::Type{T2}=eltype(x),
-    f_x::Union{Nothing,T}=nothing;
+    fdtype=Val{:central},
+    returntype=eltype(x),
+    f_x=nothing;
     relstep=default_relstep(fdtype, T),
     absstep=relstep,
-    dir=true) where {T<:Number,T1,T2}
+    dir=true) where {T<:Number}
 
     epsilon = compute_epsilon(fdtype, x, relstep, absstep, dir)
     if fdtype==Val{:forward}
@@ -71,37 +71,37 @@ Compute the derivative df of a scalar-valued map f at a collection of points x.
 =#
 function finite_difference_derivative(
     f,
-    x          :: AbstractArray{<:Number},
-    fdtype     :: Type{T1} = Val{:central},
-    returntype :: Type{T2} = eltype(x),      # return type of f
-    fx         :: Union{Nothing,AbstractArray{<:Number}} = nothing,
-    epsilon    :: Union{Nothing,AbstractArray{<:Real}} = nothing;
+    x,
+    fdtype = Val{:central},
+    returntype = eltype(x),      # return type of f
+    fx = nothing,
+    epsilon = nothing;
     relstep=default_relstep(fdtype, eltype(x)),
-    absstep=relstep) where {T1,T2}
+    absstep=relstep)
 
     df = fill(zero(returntype), size(x))
     finite_difference_derivative!(df, f, x, fdtype, returntype, fx, epsilon; relstep=relstep, absstep=absstep)
 end
 
 function finite_difference_derivative!(
-    df         :: AbstractArray{<:Number},
+    df,
     f,
-    x          :: AbstractArray{<:Number},
-    fdtype     :: Type{T1} = Val{:central},
-    returntype :: Type{T2} = eltype(x),
-    fx         :: Union{Nothing,AbstractArray{<:Number}} = nothing,
-    epsilon    :: Union{Nothing,AbstractArray{<:Real}}   = nothing;
+    x,
+    fdtype = Val{:central},
+    returntype = eltype(x),
+    fx = nothing,
+    epsilon = nothing;
     relstep=default_relstep(fdtype, eltype(x)),
-    absstep=relstep) where {T1,T2}
+    absstep=relstep)
 
     cache = DerivativeCache(x, fx, epsilon, fdtype, returntype)
     finite_difference_derivative!(df, f, x, cache; relstep=relstep, absstep=absstep)
 end
 
 function finite_difference_derivative!(
-    df::AbstractArray{<:Number},
+    df,
     f,
-    x::AbstractArray{<:Number},
+    x,
     cache::DerivativeCache{T1,T2,fdtype,returntype};
     relstep=default_relstep(fdtype, eltype(x)),
     absstep=relstep,

src/gradients.jl

@@ -5,11 +5,11 @@ struct GradientCache{CacheType1, CacheType2, CacheType3, fdtype, returntype, inp
 end
 
 function GradientCache(
-    df         :: Union{<:Number, AbstractArray{<:Number}},
-    x          :: Union{<:Number, AbstractArray{<:Number}},
-    fdtype     :: Type{T1} = Val{:central},
-    returntype :: Type{T2} = eltype(df),
-    inplace    :: Type{Val{T3}} = Val{true}) where {T1,T2,T3}
+    df,
+    x,
+    fdtype = Val{:central},
+    returntype = eltype(df),
+    inplace = Val{true})
 
     if typeof(x)<:AbstractArray # the vector->scalar case
         if fdtype!=Val{:complex} # complex-mode FD only needs one cache, for x+eps*im
@@ -49,74 +49,18 @@ function GradientCache(
 
 end
 
-function GradientCache(
-    c1         :: Union{Nothing,AbstractArray{<:Number}},
-    c2         :: Union{Nothing,AbstractArray{<:Number}},
-    fx         :: Union{Nothing,<:Number,AbstractArray{<:Number}} = nothing,
-    fdtype     :: Type{T1} = Val{:central},
-    returntype :: Type{T2} = eltype(c1),
-    inplace    :: Type{Val{T3}} = Val{true}) where {T1,T2,T3}
-
-    if fdtype!=Val{:forward} && typeof(fx)!=Nothing
-        @warn("Pre-computed function values are only useful for fdtype == Val{:forward}.")
-        _fx = nothing
-    else
-        # more runtime sanity checks?
-        _fx = fx
-    end
-
-    if typeof(x)<:AbstractArray # the vector->scalar case
-        # need cache arrays for x1 (c1) and epsilon (c2) (both only if non-StridedArray)
-        if fdtype!=Val{:complex} # complex-mode FD only needs one cache, for x+eps*im
-            if typeof(x)<:StridedVector
-                if eltype(df)<:Complex && !(eltype(x)<:Complex)
-                    _c1 = zero(Complex{eltype(x)}) .* x
-                    _c2 = nothing
-                else
-                    _c1 = nothing
-                    _c2 = nothing
-                    if typeof(c1)!=Nothing || typeof(c2)!=Nothing
-                        @warn("For StridedVectors, neither c1 nor c2 are necessary.")
-                    end
-                end
-            else
-                _c1 = c1
-                _c2 = c2
-            end
-        else
-            if !(returntype<:Real)
-                fdtype_error(returntype)
-            else
-                _c1 = x + zero(eltype(x)) .* im
-                _c2 = nothing
-            end
-        end
-
-    else # the scalar->vector case
-        # need cache arrays for fx1 and fx2, except in complex mode, which needs one complex array
-        if fdtype != Val{:complex}
-            _c1 = c1
-            _c2 = c2
-        else
-            _c1 = c1
-            _c2 = nothing
-        end
-    end
-    GradientCache{typeof(_fx),typeof(_c1),typeof(_c2),fdtype,returntype,inplace}(_fx,_c1,_c2)
-end
-
 function finite_difference_gradient(
     f,
     x,
-    fdtype::Type{T1}=Val{:central},
-    returntype::Type{T2}=eltype(x),
-    inplace::Type{Val{T3}}=Val{true},
-    fx::Union{Nothing,AbstractArray{<:Number}}=nothing,
-    c1::Union{Nothing,AbstractArray{<:Number}}=nothing,
-    c2::Union{Nothing,AbstractArray{<:Number}}=nothing;
+    fdtype = Val{:central},
+    returntype = eltype(x),
+    inplace = Val{true},
+    fx = nothing,
+    c1 = nothing,
+    c2 = nothing;
     relstep=default_relstep(fdtype, eltype(x)),
     absstep=relstep,
-    dir=true) where {T1,T2,T3}
+    dir=true)
 
     if typeof(x) <: AbstractArray
         df = zero(returntype) .* x
@@ -142,14 +86,14 @@ function finite_difference_gradient!(
     df,
     f,
     x,
-    fdtype::Type{T1}=Val{:central},
-    returntype::Type{T2}=eltype(df),
-    inplace::Type{Val{T3}}=Val{true},
-    fx::Union{Nothing,AbstractArray{<:Number}}=nothing,
-    c1::Union{Nothing,AbstractArray{<:Number}}=nothing,
-    c2::Union{Nothing,AbstractArray{<:Number}}=nothing;
+    fdtype=Val{:central},
+    returntype=eltype(df),
+    inplace=Val{true},
+    fx=nothing,
+    c1=nothing,
+    c2=nothing;
     relstep=default_relstep(fdtype, eltype(x)),
-    absstep=relstep) where {T1,T2,T3}
+    absstep=relstep)
 
     cache = GradientCache(df, x, fdtype, returntype, inplace)
     finite_difference_gradient!(df, f, x, cache, relstep=relstep, absstep=absstep)
@@ -175,9 +119,9 @@ end
 # vector of derivatives of a vector->scalar map by each component of a vector x
 # this ignores the value of "inplace", because it doesn't make much sense
 function finite_difference_gradient!(
-    df::AbstractArray{<:Number},
+    df,
     f,
-    x::AbstractArray{<:Number},
+    x,
     cache::GradientCache{T1,T2,T3,fdtype,returntype,inplace};
     relstep=default_relstep(fdtype, eltype(x)),
     absstep=relstep,
@@ -359,7 +303,7 @@ end
 # vector of derivatives of a scalar->vector map
 # this is effectively a vector of partial derivatives, but we still call it a gradient
 function finite_difference_gradient!(
-    df::AbstractArray{<:Number},
+    df,
     f,
     x::Number,
     cache::GradientCache{T1,T2,T3,fdtype,returntype,inplace};

src/hessians.jl

@@ -6,21 +6,21 @@ struct HessianCache{T,fdtype,inplace}
 end
 
 function HessianCache(xpp,xpm,xmp,xmm,
-                      fdtype::Type{T1}=Val{:hcentral},
-                      inplace::Type{Val{T2}} = x isa StaticArray ? Val{false} : Val{true}) where {T1,T2}
+                      fdtype=Val{:hcentral},
+                      inplace = x isa StaticArray ? Val{false} : Val{true})
     HessianCache{typeof(xpp),fdtype,inplace}(xpp,xpm,xmp,xmm)
 end
 
-function HessianCache(x,fdtype::Type{T1}=Val{:hcentral},
-                        inplace::Type{Val{T2}} = x isa StaticArray ? Val{false} : Val{true}) where {T1,T2}
+function HessianCache(x,fdtype=Val{:hcentral},
+                        inplace = x isa StaticArray ? Val{false} : Val{true})
     HessianCache{typeof(x),fdtype,inplace}(copy(x),copy(x),copy(x),copy(x))
 end
 
-function finite_difference_hessian(f, x::AbstractArray{<:Number},
-    fdtype     :: Type{T1}=Val{:hcentral},
-    inplace    :: Type{Val{T2}} = x isa StaticArray ? Val{false} : Val{true};
-    relstep=default_relstep(fdtype, eltype(x)),
-    absstep=relstep) where {T1,T2}
+function finite_difference_hessian(f, x,
+    fdtype  = Val{:hcentral},
+    inplace = x isa StaticArray ? Val{false} : Val{true};
+    relstep = default_relstep(fdtype, eltype(x)),
+    absstep = relstep)
 
     cache = HessianCache(x, fdtype, inplace)
     finite_difference_hessian(f, x, cache; relstep=relstep, absstep=absstep)
@@ -37,12 +37,12 @@ function finite_difference_hessian(
     Symmetric(_H isa SMatrix ? SArray(H) : H)
 end
 
-function finite_difference_hessian!(H::AbstractMatrix,f,
-    x::AbstractArray{<:Number},
-    fdtype     :: Type{T1}=Val{:hcentral},
-    inplace    :: Type{Val{T2}} = x isa StaticArray ? Val{false} : Val{true};
+function finite_difference_hessian!(H,f,
+    x,
+    fdtype  = Val{:hcentral},
+    inplace = x isa StaticArray ? Val{false} : Val{true};
     relstep=default_relstep(fdtype, eltype(x)),
-    absstep=relstep) where {T1,T2}
+    absstep=relstep)
 
     cache = HessianCache(x,fdtype,inplace)
     finite_difference_hessian!(H, f, x, cache; relstep=relstep, absstep=absstep)

src/jacobians.jl

@@ -124,16 +124,16 @@ function _make_Ji(::AbstractArray, xtype, dx, color_i, nrows, ncols)
     size(Ji)!=(nrows, ncols) ? reshape(Ji,(nrows,ncols)) : Ji #branch when size(dx) == (1,) => size(Ji) == (1,) while size(J) == (1,1)
 end
 
-function finite_difference_jacobian(f, x::AbstractArray{<:Number},
-    fdtype     :: Type{T1}=Val{:forward},
-    returntype :: Type{T2}=eltype(x),
-    f_in       :: Union{AbstractArray{<:T2},Nothing}=nothing;
+function finite_difference_jacobian(f, x,
+    fdtype     = Val{:forward},
+    returntype = eltype(x),
+    f_in       = nothing;
     relstep=default_relstep(fdtype, eltype(x)),
     absstep=relstep,
     colorvec = 1:length(x),
     sparsity = nothing,
     jac_prototype = nothing,
-    dir=true) where {T1,T2,T3}
+    dir=true)
 
     if f_in isa Nothing
         fx = f(x)
@@ -254,16 +254,16 @@ function finite_difference_jacobian(
     J
 end
 
-function finite_difference_jacobian!(J::AbstractMatrix,
+function finite_difference_jacobian!(J,
     f,
-    x::AbstractArray{<:Number},
-    fdtype     :: Type{T1}=Val{:forward},
-    returntype :: Type{T2}=eltype(x),
-    f_in       :: Union{AbstractArray{<:T2},Nothing}=nothing;
+    x,
+    fdtype     = Val{:forward},
+    returntype = eltype(x),
+    f_in       = nothing;
     relstep=default_relstep(fdtype, eltype(x)),
     absstep=relstep,
     colorvec = 1:length(x),
-    sparsity = ArrayInterface.has_sparsestruct(J) ? J : nothing) where {T1,T2}
+    sparsity = ArrayInterface.has_sparsestruct(J) ? J : nothing)
     if f_in isa Nothing && fdtype == Val{:forward}
         if size(J,1) == length(x)
             fx = zero(x)
@@ -281,15 +281,15 @@ function finite_difference_jacobian!(J::AbstractMatrix,
 end
 
 function finite_difference_jacobian!(
-    J::AbstractMatrix{<:Number},
+    J,
     f,
-    x::AbstractArray{<:Number},
+    x,
     cache::JacobianCache{T1,T2,T3,cType,sType,fdtype,returntype},
-    f_in::Union{T2,Nothing}=nothing;
+    f_in = nothing;
     relstep = default_relstep(fdtype, eltype(x)),
-    absstep=relstep,
+    absstep = relstep,
     colorvec = cache.colorvec,
-    sparsity::Union{AbstractArray,Nothing} = cache.sparsity,
+    sparsity = cache.sparsity,
     dir = true) where {T1,T2,T3,cType,sType,fdtype,returntype}
 
     m, n = size(J)

test/finitedifftests.jl

@@ -1,5 +1,9 @@
 using FiniteDiff, Test, LinearAlgebra
 
+# code quality guards
+@test isempty(detect_unbound_args(FiniteDiff))
+@test isempty(detect_ambiguities(FiniteDiff) )
+
 # TODO: add tests for GPUArrays
 # TODO: add tests for DEDataArrays