Merge pull request #37 from JuliaNLSolvers/newdf2

Use NLSolversBase

Author: anriseth

README.md

@@ -22,10 +22,10 @@ We solve the Rosenbrock problem with two different line search algorithms.
 
 First, run `Newton` with the default line search algorithm:
 ```julia
-using Optim
+using Optim, LineSearches
 prob = Optim.UnconstrainedProblems.examples["Rosenbrock"]
 
-algo_hz = Newton(;linesearch! = hagerzhang!)
+algo_hz = Newton(linesearch = hagerzhang!)
 res_hz = Optim.optimize(prob.f, prob.g!, prob.h!, prob.initial_x, method=algo_hz)
 ```
 
@@ -34,38 +34,43 @@ This gives the result
 Results of Optimization Algorithm
  * Algorithm: Newton's Method
  * Starting Point: [0.0,0.0]
- * Minimizer: [0.9999999999979515,0.9999999999960232]
- * Minimum: 5.639268e-24
- * Iterations: 13
+ * Minimizer: [0.9999999999999994,0.9999999999999989]
+ * Minimum: 3.081488e-31
+ * Iterations: 14
  * Convergence: true
    * |x - x'| < 1.0e-32: false
    * |f(x) - f(x')| / |f(x)| < 1.0e-32: false
    * |g(x)| < 1.0e-08: true
+   * f(x) > f(x'): false
    * Reached Maximum Number of Iterations: false
- * Objective Function Calls: 54
- * Gradient Calls: 54
+ * Objective Calls: 44
+ * Gradient Calls: 44
+ * Hessian Calls: 14
 ```
 
-Now we can try `Newton` with the Moré Thuente line search:
+Now we can try `Newton` with the cubic backtracking line search:
 ``` julia
-algo_mt = Newton(;linesearch! = morethuente!)
-res_mt = Optim.optimize(prob.f, prob.g!, prob.h!, prob.initial_x, method=algo_mt)
+algo_bt3 = Newton(linesearch = bt3!)
+res_bt3 = Optim.optimize(prob.f, prob.g!, prob.h!, prob.initial_x, method=algo_bt3)
 ```
 
 This gives the following result, reducing the number of function and gradient calls:
 ``` julia
+Results of Optimization Algorithm
  * Algorithm: Newton's Method
  * Starting Point: [0.0,0.0]
- * Minimizer: [0.9999999999999992,0.999999999999998]
- * Minimum: 2.032549e-29
+ * Minimizer: [0.9999999959215587,0.9999999918223065]
+ * Minimum: 1.667699e-17
  * Iterations: 14
  * Convergence: true
    * |x - x'| < 1.0e-32: false
    * |f(x) - f(x')| / |f(x)| < 1.0e-32: false
    * |g(x)| < 1.0e-08: true
+   * f(x) > f(x'): false
    * Reached Maximum Number of Iterations: false
- * Objective Function Calls: 45
- * Gradient Calls: 45
+ * Objective Calls: 19
+ * Gradient Calls: 15
+ * Hessian Calls: 14
 ```
 
 ## References

REQUIRE

@@ -1 +1,2 @@
 julia 0.5
+NLSolversBase

src/LineSearches.jl

@@ -2,6 +2,7 @@ isdefined(Base, :__precompile__) && __precompile__()
 
 module LineSearches
 
+import NLSolversBase
 import Base.clear!
 
 export LineSearchResults, LineSearchException

src/api.jl

@@ -13,8 +13,6 @@ function alphatry{T}(alpha::T,
                      iterfinitemax::Integer = ceil(Integer, -log2(eps(T))),
                      alphamax::Real = convert(T, Inf),
                      verbose::Bool = false)
-    f_calls = 0
-    g_calls = 0
 
     phi0 = lsr.value[1]
     dphi0 = lsr.slope[1]
@@ -23,19 +21,17 @@ function alphatry{T}(alpha::T,
     alphatest = min(alphatest, alphamax)
 
     # Use xtmp here
-    phitest = df.f(x + alphatest * s)
-    f_calls += 1
+    phitest = NLSolversBase.value!(df, x + alphatest * s)
 
     iterfinite = 1
     while !isfinite(phitest)
         alphatest = psi3 * alphatest
         # Use xtmp here
-        phitest = df.f(x + alphatest * s)
-        f_calls += 1
+        phitest = NLSolversBase.value!(df, x + alphatest * s)
         lsr.nfailures += 1
         iterfinite += 1
         if iterfinite >= iterfinitemax
-            return zero(T), true, f_calls, g_calls
+            return zero(T), true
 #             error("Failed to achieve finite test value; alphatest = ", alphatest)
         end
     end
@@ -73,7 +69,7 @@ function alphatry{T}(alpha::T,
     if verbose == true
         println("alpha guess (expand): ", alpha)
     end
-    return alpha, mayterminate, f_calls, g_calls
+    return alpha, mayterminate
 end
 
 

src/backtracking.jl

@@ -66,10 +66,6 @@ function backtracking!{T}(df,
     # Count the total number of iterations
     iteration = 0
 
-    # Track calls to function and gradient
-    f_calls = 0
-    g_calls = 0
-
     # Count number of parameters
     n = length(x)
 
@@ -84,17 +80,16 @@ function backtracking!{T}(df,
     push!(lsr.alpha, alpha)
 
     # Backtrack until we satisfy sufficient decrease condition
-    f_x_scratch = df.f(x_scratch)
+    f_x_scratch = NLSolversBase.value!(df, x_scratch)
     push!(lsr.value, f_x_scratch)
-    f_calls += 1
     while f_x_scratch > f_x + c1 * alpha * gxp
         # Increment the number of steps we've had to perform
         iteration += 1
 
         # Ensure termination
         if iteration > iterations
             throw(LineSearchException("Linesearch failed to converge, reached maximum iterations $(iterations).",
-                                      lsr.alpha[end], f_calls, g_calls,lsr))
+                                      lsr.alpha[end], lsr))
         end
 
         # Shrink proposed step-size:
@@ -135,10 +130,9 @@ function backtracking!{T}(df,
         end
 
         # Evaluate f(x) at proposed position
-        f_x_scratch = df.f(x_scratch)
-        f_calls += 1
+        f_x_scratch = NLSolversBase.value!(df, x_scratch)
         push!(lsr.value, f_x_scratch)
     end
 
-    return alpha, f_calls, g_calls
+    return alpha
 end

src/basic.jl

@@ -21,11 +21,8 @@ function basic!{T}(df,
     end
 
     # Evaluate f(x) at new position
-    f_x_scratch = df.f(x_scratch)
+    f_x_scratch = NLSolversBase.value!(df, x_scratch)
     push!(lsr.value, f_x_scratch)
-    f_calls = 1
 
-    g_calls = 0
-
-    return alpha, f_calls, g_calls
+    return alpha
 end

src/deprecate.jl

@@ -1,9 +1 @@
 # Deprecation warnings
-
-@deprecate hz_linesearch! hagerzhang!
-@deprecate mt_linesearch! morethuente!
-@deprecate backtracking_linesearch! backtracking!
-@deprecate interpbacktrack_linesearch! bt2!
-@deprecate interpolating_linesearch! strongwolfe!
-@deprecate LinesearchException LineSearchException
-@deprecate interpbacktrack! bt2!