Merge pull request #65 from JuliaIntervals/lb/iss64

Add deriv as another parameter of roots (instead of a keyword arg)

Author: lbenet

src/roots.jl

@@ -119,7 +119,8 @@ IntervalLike{T} = Union{Interval{T}, IntervalBox{T}}
 NewtonLike = Union{Type{Newton}, Type{Krawczyk}}
 
 """
-    roots(f, X, contractor, tol=1e-3 ; deriv=nothing)
+    roots(f, X, contractor, tol=1e-3)
+    roots(f, deriv, X, contractor, tol=1e-3)
 
 Uses a generic branch and prune routine to find in principle all isolated roots of a function
 `f:R^n → R^n` in a box `X`, or a vector of boxes.
@@ -134,36 +135,45 @@ Inputs:
 
 """
 # Contractor specific `roots` functions
-function roots(f, X::IntervalLike{T}, ::Type{Bisection}, tol::Float64=1e-3; deriv = nothing) where {T}
+function roots(f, X::IntervalLike{T}, ::Type{Bisection}, tol::Float64=1e-3) where {T}
     branch_and_prune(X, Bisection(f), tol)
 end
 
-function roots(f, X::Interval{T}, C::NewtonLike, tol::Float64=1e-3; deriv = nothing) where {T}
+function roots(f, X::Interval{T}, C::NewtonLike, tol::Float64=1e-3) where {T}
 
-    if deriv == nothing
-        deriv = x -> ForwardDiff.derivative(f, x)
-    end
+    deriv = x -> ForwardDiff.derivative(f, x)
+
+    roots(f, deriv, X, C, tol)
+end
 
+function roots(f, deriv, X::Interval{T}, C::NewtonLike, tol::Float64=1e-3) where {T}
     branch_and_prune(X, C(f, deriv), tol)
 end
 
-function roots(f, X::IntervalBox{T}, C::NewtonLike, tol::Float64=1e-3; deriv = nothing) where {T}
+function roots(f, X::IntervalBox{T}, C::NewtonLike, tol::Float64=1e-3) where {T}
 
-    if deriv == nothing
-        deriv = x -> ForwardDiff.jacobian(f, x)
-    end
+    deriv = x -> ForwardDiff.jacobian(f, x)
 
+    roots(f, deriv, X, C, tol)
+end
+
+function roots(f, deriv, X::IntervalBox{T}, C::NewtonLike, tol::Float64=1e-3) where {T}
     branch_and_prune(X, C(f, deriv), tol)
 end
 
-roots(f, r::Root, contractor::Type{C}, tol::Float64=1e-3; deriv = nothing) where {C<:Contractor}  = roots(f, r.interval, contractor, tol; deriv = deriv)
+roots(f, r::Root, contractor::Type{C}, tol::Float64=1e-3) where {C<:Contractor} =
+    roots(f, r.interval, contractor, tol)
+roots(f, deriv, r::Root, contractor::Type{C}, tol::Float64=1e-3) where {C<:Contractor} =
+    roots(f, deriv, r.interval, contractor, tol)
 
 
 # Acting on a Vector:
 
 # TODO: Use previous status information about roots:
-roots(f, V::Vector{Root{T}}, contractor::Type{C}, tol::Float64=1e-3;
-    deriv = nothing) where {T, C<:Contractor} = vcat(roots.(f, V, contractor, tol; deriv = deriv)...)
+roots(f, V::Vector{Root{T}}, contractor::Type{C}, tol::Float64=1e-3) where {T, C<:Contractor} =
+    vcat(roots.(f, V, contractor, tol)...)
+roots(f, deriv, V::Vector{Root{T}}, contractor::Type{C}, tol::Float64=1e-3) where {T, C<:Contractor} =
+    vcat(roots.(f, deriv, V, contractor, tol)...)
 
 
 
@@ -179,22 +189,30 @@ function roots(f, Xc::Complex{Interval{T}}, contractor::Type{C},
     return [Root(Complex(root.interval...), root.status) for root in rts]
 end
 
-function roots(f, Xc::Complex{Interval{T}}, C::NewtonLike, tol::Float64=1e-3;
-        deriv = nothing) where {T}
+function roots(f, Xc::Complex{Interval{T}}, C::NewtonLike, tol::Float64=1e-3) where {T}
 
     g = realify(f)
 
-    if deriv == nothing
-        g_prime = x -> ForwardDiff.jacobian(g, x)
-    else
-        g_prime = realify_derivative(deriv)
-    end
+    g_prime = x -> ForwardDiff.jacobian(g, x)
+
+    Y = IntervalBox(reim(Xc))
+    rts = roots(g, g_prime, Y, C, tol)
+
+    return [Root(Complex(root.interval...), root.status) for root in rts]
+end
+
+function roots(f, deriv, Xc::Complex{Interval{T}}, C::NewtonLike, tol::Float64=1e-3) where {T}
+
+    g = realify(f)
+
+    g_prime = realify_derivative(deriv)
 
     Y = IntervalBox(reim(Xc))
-    rts = roots(g, Y, C, tol; deriv=g_prime)
+    rts = roots(g, g_prime, Y, C, tol)
 
     return [Root(Complex(root.interval...), root.status) for root in rts]
 end
 
 # Default
-roots(f, X, tol::Float64=1e-15; deriv = nothing) = roots(f, X, Newton, tol; deriv = deriv)
+roots(f::F, deriv::F, X, tol::Float64=1e-15) where {F<:Function} = roots(f, deriv, X, Newton, tol)
+roots(f::F, X, tol::Float64=1e-15) where {F<:Function} = roots(f, X, Newton, tol)

test/roots.jl

@@ -6,11 +6,11 @@ function all_unique(rts)
     all(root_status.(rts) .== :unique)
 end
 
-function test_newtonlike(f, X, method, nsol, tol=1e-3; deriv=nothing)
+function test_newtonlike(f, deriv, X, method, nsol, tol=1e-3)
     rts = roots(f, X, method)
     @test length(rts) == nsol
     @test all_unique(rts)
-    @test rts == roots(f, X, method; deriv = deriv)
+    @test rts == roots(f, deriv, X, method)
 end
 
 newtonlike_methods = [Newton, Krawczyk]
@@ -30,7 +30,7 @@ newtonlike_methods = [Newton, Krawczyk]
     @test all_unique(rts)
 
     for method in newtonlike_methods
-        test_newtonlike(sin, -5..5, method, 3; deriv=cos)
+        test_newtonlike(sin, cos, -5..5, method, 3)
     end
 
     # Infinite interval
@@ -49,7 +49,8 @@ end
     @test length(rts) == 4
 
     for method in newtonlike_methods
-        test_newtonlike(f, X, method, 2; deriv = xx -> ForwardDiff.jacobian(f, xx))
+        deriv = xx -> ForwardDiff.jacobian(f, xx)
+        test_newtonlike(f, deriv, X, method, 2)
     end
 
     # Infinite interval
@@ -78,7 +79,8 @@ end
         rts = roots(g, XX, method)
         @test length(rts) == 4
         @test all_unique(rts)
-        @test rts == roots(g, XX, method; deriv = xx -> ForwardDiff.jacobian(g, xx))
+        deriv = xx -> ForwardDiff.jacobian(g, xx)
+        @test rts == roots(g, deriv, XX, method)
     end
 end
 
@@ -89,7 +91,8 @@ end
     tol = 1e-5
 
     for method in newtonlike_methods
-        test_newtonlike(gradf, XX, method, 25, tol; deriv = xx -> ForwardDiff.jacobian(gradf, xx))
+        deriv = xx -> ForwardDiff.jacobian(gradf, xx)
+        test_newtonlike(gradf, deriv, XX, method, 25, tol)
     end
 end
 
@@ -107,7 +110,8 @@ end
     @test length(rts) == 7
 
     for method in newtonlike_methods
-        test_newtonlike(f, Xc, method, 3; deriv = z -> 3*z^2)
+        deriv = z -> 3*z^2
+        test_newtonlike(f, deriv, Xc, method, 3)
     end
 end