Skip to content

Commit

Permalink
Merge pull request #11 from JuliaDiffEq/fbot/deps
Browse files Browse the repository at this point in the history 
Fix deprecations
  • Loading branch information
@ChrisRackauckas
ChrisRackauckas authored Aug 17, 2017
2 parents 04bfbe9 + 6a37292 commit d21022e
Showing 1 changed file with 19 additions and 19 deletions.
38 changes: 19 additions & 19 deletions src/finitediff.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,15 +6,15 @@ 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{T<:Real}(::Type{Val{:forward}}, x::T, eps_sqrt::T=sqrt(eps(T)))
@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))
end

@inline function compute_epsilon{T<:Real}(::Type{Val{:central}}, x::T, eps_cbrt::T=cbrt(eps(T)))
@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))
end

@inline function compute_epsilon_factor{T<:Real}(fdtype::DataType, ::Type{T})
@inline function compute_epsilon_factor(fdtype::DataType, ::Type{T}) where T<:Real
if fdtype==Val{:forward}
return sqrt(eps(T))
elseif fdtype==Val{:central}
Expand All @@ -30,12 +30,12 @@ Compute the derivative df of a real-valued callable f on a collection of points
Generic fallbacks for AbstractArrays that are not StridedArrays.
# TODO: test the fallbacks
=#
function finite_difference{T<:Real}(f, x::AbstractArray{T}, fdtype::DataType, fx::Union{Void,AbstractArray{T}}=nothing, funtype::DataType=Val{:Default})
function finite_difference(f, x::AbstractArray{T}, fdtype::DataType, fx::Union{Void,AbstractArray{T}}=nothing, funtype::DataType=Val{:Default}) where T<:Real
df = zeros(T, size(x))
finite_difference!(df, f, x, fdtype, fx, funtype)
end

function finite_difference!{T<:Real}(df::AbstractArray{T}, f, x::AbstractArray{T}, fdtype::DataType, fx::Union{Void,AbstractArray{T}}, ::Type{Val{:Default}})
function finite_difference!(df::AbstractArray{T}, f, x::AbstractArray{T}, fdtype::DataType, fx::Union{Void,AbstractArray{T}}, ::Type{Val{:Default}}) where T<:Real
if fdtype == Val{:forward}
epsilon_factor = compute_epsilon_factor(fdtype, T)
@. epsilon = compute_epsilon(fdtype, x, epsilon_factor)
Expand All @@ -55,7 +55,7 @@ function finite_difference!{T<:Real}(df::AbstractArray{T}, f, x::AbstractArray{T
df
end

function finite_difference!{T<:Real}(df::AbstractArray{T}, f, x::T, fdtype::DataType, fx::AbstractArray{T}, ::Type{Val{:DiffEqDerivativeWrapper}})
function finite_difference!(df::AbstractArray{T}, f, x::T, fdtype::DataType, fx::AbstractArray{T}, ::Type{Val{:DiffEqDerivativeWrapper}}) where T<:Real
fx1 = f.fx1
if fdtype == Val{:forward}
epsilon = compute_epsilon(fdtype, x)
Expand All @@ -79,7 +79,7 @@ end
Compute the derivative df of a real-valued callable f on a collection of points x.
Optimized implementations for StridedArrays.
=#
function finite_difference!{T<:Real}(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, ::Union{Void,StridedArray{T}}, ::Type{Val{:Default}})
function finite_difference!(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, ::Union{Void,StridedArray{T}}, ::Type{Val{:Default}}) where T<:Real
epsilon_factor = compute_epsilon_factor(Val{:central}, T)
@inbounds for i in 1 : length(x)
epsilon = compute_epsilon(Val{:central}, x[i], epsilon_factor)
Expand All @@ -90,7 +90,7 @@ function finite_difference!{T<:Real}(df::StridedArray{T}, f, x::StridedArray{T},
df
end

function finite_difference!{T<:Real}(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, ::Void, ::Type{Val{:Default}})
function finite_difference!(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, ::Void, ::Type{Val{:Default}}) where T<:Real
epsilon_factor = compute_epsilon_factor(Val{:forward}, T)
@inbounds for i in 1 : length(x)
epsilon = compute_epsilon(Val{:forward}, x[i], epsilon_factor)
Expand All @@ -101,7 +101,7 @@ function finite_difference!{T<:Real}(df::StridedArray{T}, f, x::StridedArray{T},
df
end

function finite_difference!{T<:Real}(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:Default}})
function finite_difference!(df::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:Default}}) where T<:Real
epsilon_factor = compute_epsilon_factor(Val{:forward}, T)
@inbounds for i in 1 : length(x)
epsilon = compute_epsilon(Val{:forward}, x[i], epsilon_factor)
Expand All @@ -116,7 +116,7 @@ end
Compute the derivative df of a real-valued callable f on a collection of points x.
Single point implementations.
=#
function finite_difference{T<:Real}(f, x::T, fdtype::DataType, f_x::Union{Void,T}=nothing)
function finite_difference(f, x::T, fdtype::DataType, f_x::Union{Void,T}=nothing) where T<:Real
if fdtype == Val{:complex}
epsilon = eps(T)
return imag(f(x+im*epsilon)) / epsilon
Expand All @@ -126,15 +126,15 @@ function finite_difference{T<:Real}(f, x::T, fdtype::DataType, f_x::Union{Void,T
end
end

@inline function finite_difference_kernel{T<:Real}(f, x::T, ::Type{Val{:forward}}, epsilon::T, fx::Union{Void,T})
@inline function finite_difference_kernel(f, x::T, ::Type{Val{:forward}}, epsilon::T, fx::Union{Void,T}) where T<:Real
if typeof(fx) == Void
return (f(x+epsilon) - f(x)) / epsilon
else
return (f(x+epsilon) - fx) / epsilon
end
end

@inline function finite_difference_kernel{T<:Real}(f, x::T, ::Type{Val{:central}}, epsilon::T, ::Union{Void,T}=nothing)
@inline function finite_difference_kernel(f, x::T, ::Type{Val{:central}}, epsilon::T, ::Union{Void,T}=nothing) where T<:Real
(f(x+epsilon) - f(x-epsilon)) / (2 * epsilon)
end

Expand All @@ -144,7 +144,7 @@ end
#=
Compute the Jacobian matrix of a real-valued callable f: R^n -> R^m.
=#
function finite_difference_jacobian{T<:Real}(f, x::AbstractArray{T}, fdtype::DataType=Val{:central}, funtype::DataType=Val{:Default})
function finite_difference_jacobian(f, x::AbstractArray{T}, fdtype::DataType=Val{:central}, funtype::DataType=Val{:Default}) where T<:Real
if funtype==Val{:Default}
fx = f.(x)
elseif funtype==Val{:DiffEqJacobianWrapper}
Expand All @@ -156,7 +156,7 @@ function finite_difference_jacobian{T<:Real}(f, x::AbstractArray{T}, fdtype::Dat
finite_difference_jacobian!(J, f, x, fdtype, fx, funtype)
end

function finite_difference_jacobian!{T<:Real}(J::AbstractArray{T}, f, x::AbstractArray{T}, fdtype::DataType, fx::AbstractArray{T}, ::DataType)
function finite_difference_jacobian!(J::AbstractArray{T}, f, x::AbstractArray{T}, fdtype::DataType, fx::AbstractArray{T}, ::DataType) where T<:Real
# This is an inefficient fallback that only makes sense if setindex/getindex are unavailable, e.g. GPUArrays etc.
m, n = size(J)
epsilon_factor = compute_epsilon_factor(fdtype, T)
Expand Down Expand Up @@ -185,7 +185,7 @@ function finite_difference_jacobian!{T<:Real}(J::AbstractArray{T}, f, x::Abstrac
J
end

function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, fx::StridedArray{T}, ::Type{Val{:Default}})
function finite_difference_jacobian!(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, fx::StridedArray{T}, ::Type{Val{:Default}}) where T<:Real
m, n = size(J)
epsilon_factor = compute_epsilon_factor(Val{:central}, T)
@inbounds for i in 1:n
Expand All @@ -202,7 +202,7 @@ function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedA
J
end

function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:Default}})
function finite_difference_jacobian!(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:Default}}) where T<:Real
m, n = size(J)
epsilon_factor = compute_epsilon_factor(Val{:forward}, T)
@inbounds for i in 1:n
Expand All @@ -219,7 +219,7 @@ function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedA
J
end

function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:complex}}, fx::StridedArray{T}, ::Type{Val{:Default}})
function finite_difference_jacobian!(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:complex}}, fx::StridedArray{T}, ::Type{Val{:Default}}) where T<:Real
m, n = size(J)
epsilon = eps(T)
epsilon_inv = one(T) / epsilon
Expand All @@ -236,7 +236,7 @@ function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedA
end

# efficient implementations for OrdinaryDiffEq Jacobian wrappers, assuming the system function supplies StridedArrays
function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:JacobianWrapper}})
function finite_difference_jacobian!(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:forward}}, fx::StridedArray{T}, ::Type{Val{:JacobianWrapper}}) where T<:Real
m, n = size(J)
epsilon_factor = compute_epsilon_factor(Val{:forward}, T)
x1, fx1 = f.x1, f.fx1
Expand All @@ -254,7 +254,7 @@ function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedA
J
end

function finite_difference_jacobian!{T<:Real}(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, fx::StridedArray{T}, ::Type{Val{:JacobianWrapper}})
function finite_difference_jacobian!(J::StridedArray{T}, f, x::StridedArray{T}, ::Type{Val{:central}}, fx::StridedArray{T}, ::Type{Val{:JacobianWrapper}}) where T<:Real
m, n = size(J)
epsilon_factor = compute_epsilon_factor(Val{:central}, T)
x1, fx1 = f.x1, f.fx1
Expand Down

0 comments on commit d21022e

Please sign in to comment.