NonDifferentiableFunction -> NonDifferentiable, DifferentiableFunctio…

docs/src/algo/precondition.md

@@ -40,7 +40,7 @@ initial_x = zeros(100)
 plap(U; n = length(U)) = (n-1)*sum((0.1 + diff(U).^2).^2 ) - sum(U) / (n-1)
 plap1 = ForwardDiff.gradient(plap)
 precond(n) = spdiagm((-ones(n-1), 2*ones(n), -ones(n-1)), (-1,0,1), n, n)*(n+1)
-df = DifferentiableFunction(x -> plap([0; X; 0]),
+df = OnceDifferentiable(x -> plap([0; X; 0]),
                             (x, g) -> copy!(g, (plap1([0; X; 0]))[2:end-1]))
 result = Optim.optimize(df, initial_x, method = ConjugateGradient(P = nothing))
 result = Optim.optimize(df, initial_x, method = ConjugateGradient(P = precond(100)))

docs/src/user/minimization.md

@@ -75,7 +75,7 @@ A primal interior-point algorithm for simple "box" constraints (lower and upper
 lower = [1.25, -2.1]
 upper = [Inf, Inf]
 initial_x = [2.0, 2.0]
-results = optimize(DifferentiableFunction(f, g!), initial_x, lower, upper, Fminbox(), optimizer = GradientDescent)
+results = optimize(OnceDifferentiable(f, g!), initial_x, lower, upper, Fminbox(), optimizer = GradientDescent)
 ```
 
 This performs optimization with a barrier penalty, successively scaling down the barrier coefficient and using the chosen `optimizer` for convergence at each step. Notice that the `Optimizer` type, not an instance should be passed. This means that the keyword should be passed as `optimizer = GradientDescent` not `optimizer = GradientDescent()`, as you usually would.
@@ -86,11 +86,11 @@ There are two iterations parameters: an outer iterations parameter used to contr
 
 For example, the following restricts the optimization to 2 major iterations
 ```julia
-results = optimize(DifferentiableFunction(f, g!), initial_x, lower, upper, Fminbox(); optimizer = GradientDescent, iterations = 2)
+results = optimize(OnceDifferentiable(f, g!), initial_x, lower, upper, Fminbox(); optimizer = GradientDescent, iterations = 2)
 ```
 In contrast, the following sets the maximum number of iterations for each `ConjugateGradient` optimization to 2
 ```julia
-results = Optim.optimize(DifferentiableFunction(f, g!), initial_x, lower, upper, Fminbox(); optimizer = GradientDescent, optimizer_o = Optim.Options(iterations = 2))
+results = Optim.optimize(OnceDifferentiable(f, g!), initial_x, lower, upper, Fminbox(); optimizer = GradientDescent, optimizer_o = Optim.Options(iterations = 2))
 ```
 ## Minimizing a univariate function on a bounded interval
 

docs/src/user/tipsandtricks.md

@@ -81,7 +81,7 @@ using Optim
 initial_x = ...
 buffer = Array{eltype(initial_x)}(...) # Preallocate an appropriate buffer
 last_x = similar(initial_x)
-df = TwiceDifferentiableFunction(x -> f(x, buffer, initial_x),
+df = TwiceDifferentiable(x -> f(x, buffer, initial_x),
                                 (x, stor) -> g!(x, stor, buffer, last_x))
 optimize(df, initial_x)
 ```

src/Optim.jl

@@ -17,8 +17,12 @@ module Optim
            Base.setindex!
 
     export optimize,
-           DifferentiableFunction,
+           NonDifferentiableFunction,
+           OnceDifferentiableFunction,
            TwiceDifferentiableFunction,
+           NonDifferentiable,
+           OnceDifferentiable,
+           TwiceDifferentiable,
            OptimizationOptions,
            OptimizationState,
            OptimizationTrace,

src/deprecate.jl

@@ -73,3 +73,7 @@ function get_neighbor(neighbor!, neighbor)
     end
     neighbor
 end
+
+@deprecate NonDifferentiableFunction(args...) NonDifferentiable(args)
+@deprecate DifferentiableFunction(args...) OnceDifferentiable(args)
+@deprecate TwiceDifferentiableFunction(args...) TwiceDifferentiable(args)

src/fminbox.jl

@@ -103,7 +103,7 @@ end
 immutable Fminbox <: Optimizer end
 
 function optimize{T<:AbstractFloat}(
-        df::DifferentiableFunction,
+        df::OnceDifferentiable,
         initial_x::Array{T},
         l::Array{T},
         u::Array{T},
@@ -183,7 +183,7 @@ function optimize{T<:AbstractFloat}(
         # Optimize with current setting of mu
         funcc = (x, g) -> barrier_combined(x, g, gfunc, gbarrier, fb, mu)
         fval0 = funcc(x, nothing)
-        dfbox = DifferentiableFunction(x->funcc(x,nothing), (x,g)->(funcc(x,g); g), funcc)
+        dfbox = OnceDifferentiable(x->funcc(x,nothing), (x,g)->(funcc(x,g); g), funcc)
         if show_trace > 0
             println("#### Calling optimizer with mu = ", mu, " ####")
         end

src/optimize.jl

@@ -28,7 +28,7 @@ function optimize{F<:Function, G<:Function}(f::F, g!::G, initial_x::Array; kwarg
     checked_kwargs, method = check_kwargs(kwargs, BFGS())
     optimize(f, g!, initial_x, method, Options(;checked_kwargs...))
 end
-function optimize(d::DifferentiableFunction, initial_x::Array; kwargs...)
+function optimize(d::OnceDifferentiable, initial_x::Array; kwargs...)
     checked_kwargs, method = check_kwargs(kwargs, BFGS())
     optimize(d, initial_x, method, Options(checked_kwargs...))
 end
@@ -41,28 +41,28 @@ function optimize{F<:Function, G<:Function, H<:Function}(f::F,
     optimize(f, g!, h!, initial_x, method, Options(checked_kwargs...))
 end
 
-function optimize(d::TwiceDifferentiableFunction, initial_x::Array; kwargs...)
+function optimize(d::TwiceDifferentiable, initial_x::Array; kwargs...)
     checked_kwargs, method = check_kwargs(kwargs, Newton())
     optimize(d, initial_x, method, Options(;kwargs...))
 end
 
 optimize(d::Function, initial_x, options::Options) = optimize(d, initial_x, NelderMead(), options)
-optimize(d::DifferentiableFunction, initial_x, options::Options) = optimize(d, initial_x, BFGS(), options)
-optimize(d::TwiceDifferentiableFunction, initial_x, options::Options) = optimize(d, initial_x, Newton(), options)
+optimize(d::OnceDifferentiable, initial_x, options::Options) = optimize(d, initial_x, BFGS(), options)
+optimize(d::TwiceDifferentiable, initial_x, options::Options) = optimize(d, initial_x, Newton(), options)
 
 function optimize{F<:Function, G<:Function}(f::F,
                   g!::G,
                   initial_x::Array,
                   method::Optimizer,
                   options::Options = Options())
-    d = DifferentiableFunction(f, g!)
+    d = OnceDifferentiable(f, g!)
     optimize(d, initial_x, method, options)
 end
 function optimize{F<:Function, G<:Function}(f::F,
                   g!::G,
                   initial_x::Array,
                   options::Options)
-    d = DifferentiableFunction(f, g!)
+    d = OnceDifferentiable(f, g!)
     optimize(d, initial_x, BFGS(), options)
 end
 
@@ -72,15 +72,15 @@ function optimize{F<:Function, G<:Function, H<:Function}(f::F,
                   initial_x::Array,
                   method::Optimizer,
                   options::Options = Options())
-    d = TwiceDifferentiableFunction(f, g!, h!)
+    d = TwiceDifferentiable(f, g!, h!)
     optimize(d, initial_x, method, options)
 end
 function optimize{F<:Function, G<:Function, H<:Function}(f::F,
                   g!::G,
                   h!::H,
                   initial_x::Array,
                   options)
-    d = TwiceDifferentiableFunction(f, g!, h!)
+    d = TwiceDifferentiable(f, g!, h!)
     optimize(d, initial_x, Newton(), options)
 end
 
@@ -90,7 +90,7 @@ function optimize{F<:Function, T, M <: Union{FirstOrderSolver, SecondOrderSolver
                   options::Options)
     if !options.autodiff
         if M <: FirstOrderSolver
-            d = DifferentiableFunction(f)
+            d = OnceDifferentiable(f)
         else
             error("No gradient or Hessian was provided. Either provide a gradient and Hessian, set autodiff = true in the Options if applicable, or choose a solver that doesn't require a Hessian.")
         end
@@ -105,18 +105,18 @@ function optimize{F<:Function, T, M <: Union{FirstOrderSolver, SecondOrderSolver
         end
 
         if M <: FirstOrderSolver
-            d = DifferentiableFunction(f, g!, fg!)
+            d = OnceDifferentiable(f, g!, fg!)
         else
             hcfg = ForwardDiff.HessianConfig(initial_x)
             h! = (x, out) -> ForwardDiff.hessian!(out, f, x, hcfg)
-            d = TwiceDifferentiableFunction(f, g!, fg!, h!)
+            d = TwiceDifferentiable(f, g!, fg!, h!)
         end
     end
 
     optimize(d, initial_x, method, options)
 end
 
-function optimize(d::DifferentiableFunction,
+function optimize(d::OnceDifferentiable,
                   initial_x::Array,
                   method::Newton,
                   options::Options)
@@ -126,10 +126,10 @@ function optimize(d::DifferentiableFunction,
         hcfg = ForwardDiff.HessianConfig(initial_x)
         h! = (x, out) -> ForwardDiff.hessian!(out, d.f, x, hcfg)
     end
-    optimize(TwiceDifferentiableFunction(d.f, d.g!, d.fg!, h!), initial_x, method, options)
+    optimize(TwiceDifferentiable(d.f, d.g!, d.fg!, h!), initial_x, method, options)
 end
 
-function optimize(d::DifferentiableFunction,
+function optimize(d::OnceDifferentiable,
                   initial_x::Array,
                   method::NewtonTrustRegion,
                   options::Options)
@@ -139,7 +139,7 @@ function optimize(d::DifferentiableFunction,
         hcfg = ForwardDiff.HessianConfig(initial_x)
         h! = (x, out) -> ForwardDiff.hessian!(out, d.f, x, hcfg)
     end
-    optimize(TwiceDifferentiableFunction(d.f, d.g!, d.fg!, h!), initial_x, method, options)
+    optimize(TwiceDifferentiable(d.f, d.g!, d.fg!, h!), initial_x, method, options)
 end
 
 update_g!(d, state, method) = nothing

src/types.jl

@@ -93,17 +93,17 @@ type UnivariateOptimizationResults{T,M} <: OptimizationResults
     f_calls::Int
 end
 
-immutable NonDifferentiableFunction
+immutable NonDifferentiable
     f::Function
 end
 
-immutable DifferentiableFunction
+immutable OnceDifferentiable
     f::Function
     g!::Function
     fg!::Function
 end
 
-immutable TwiceDifferentiableFunction
+immutable TwiceDifferentiable
     f::Function
     g!::Function
     fg!::Function
@@ -187,7 +187,7 @@ function Base.append!(a::MultivariateOptimizationResults, b::MultivariateOptimiz
 end
 
 # TODO: Expose ability to do forward and backward differencing
-function DifferentiableFunction(f::Function)
+function OnceDifferentiable(f::Function)
     function g!(x::Array, storage::Array)
         Calculus.finite_difference!(f, x, storage, :central)
         return
@@ -196,18 +196,18 @@ function DifferentiableFunction(f::Function)
         g!(x, storage)
         return f(x)
     end
-    return DifferentiableFunction(f, g!, fg!)
+    return OnceDifferentiable(f, g!, fg!)
 end
 
-function DifferentiableFunction(f::Function, g!::Function)
+function OnceDifferentiable(f::Function, g!::Function)
     function fg!(x::Array, storage::Array)
         g!(x, storage)
         return f(x)
     end
-    return DifferentiableFunction(f, g!, fg!)
+    return OnceDifferentiable(f, g!, fg!)
 end
 
-function TwiceDifferentiableFunction(f::Function)
+function TwiceDifferentiable(f::Function)
     function g!(x::Vector, storage::Vector)
         Calculus.finite_difference!(f, x, storage, :central)
         return
@@ -220,15 +220,15 @@ function TwiceDifferentiableFunction(f::Function)
         Calculus.finite_difference_hessian!(f, x, storage)
         return
     end
-    return TwiceDifferentiableFunction(f, g!, fg!, h!)
+    return TwiceDifferentiable(f, g!, fg!, h!)
 end
 
-function TwiceDifferentiableFunction(f::Function,
+function TwiceDifferentiable(f::Function,
                                      g!::Function,
                                      h!::Function)
     function fg!(x::Vector, storage::Vector)
         g!(x, storage)
         return f(x)
     end
-    return TwiceDifferentiableFunction(f, g!, fg!, h!)
+    return TwiceDifferentiable(f, g!, fg!, h!)
 end

test/accelerated_gradient_descent.jl

@@ -6,7 +6,7 @@
         return
     end
 
-    d = DifferentiableFunction(f, g!)
+    d = OnceDifferentiable(f, g!)
 
     initial_x = [1.0]
     options = Optim.Options(show_trace = true, iterations = 10)

test/api.jl

@@ -6,9 +6,9 @@
     h! = rosenbrock.h!
     initial_x = rosenbrock.initial_x
 
-    d1 = DifferentiableFunction(f)
-    d2 = DifferentiableFunction(f, g!)
-    d3 = TwiceDifferentiableFunction(f, g!, h!)
+    d1 = OnceDifferentiable(f)
+    d2 = OnceDifferentiable(f, g!)
+    d3 = TwiceDifferentiable(f, g!, h!)
 
     Optim.optimize(f, initial_x, BFGS())
     Optim.optimize(f, g!, initial_x, BFGS())

test/callbacks.jl

@@ -5,8 +5,8 @@
     g! = problem.g!
     h! = problem.h!
     initial_x = problem.initial_x
-    d2 = DifferentiableFunction(f, g!)
-    d3 = TwiceDifferentiableFunction(f, g!, h!)
+    d2 = OnceDifferentiable(f, g!)
+    d3 = TwiceDifferentiable(f, g!, h!)
 
     for method in (NelderMead(), SimulatedAnnealing())
         ot_run = false

test/cg.jl

@@ -2,7 +2,7 @@
 	# Test Optim.cg for all differentiable functions in Optim.UnconstrainedProblems.examples
 	for (name, prob) in Optim.UnconstrainedProblems.examples
 		if prob.isdifferentiable
-			df = DifferentiableFunction(prob.f, prob.g!)
+			df = OnceDifferentiable(prob.f, prob.g!)
 			res = Optim.optimize(df, prob.initial_x, ConjugateGradient())
 				@test norm(Optim.minimizer(res) - prob.solutions) < 1e-2
 		end
@@ -19,7 +19,7 @@
 
 	srand(1)
 	B = rand(2,2)
-	df = Optim.DifferentiableFunction(X -> objective(X, B), (X, G) -> objective_gradient!(X, G, B))
+	df = Optim.OnceDifferentiable(X -> objective(X, B), (X, G) -> objective_gradient!(X, G, B))
 	results = Optim.optimize(df, rand(2,2), ConjugateGradient())
 	@test Optim.converged(results)
 	@test Optim.minimum(results) < 1e-8

test/constrained.jl

@@ -26,7 +26,7 @@
         initial_x = randn(N)
         tmp = similar(initial_x)
         func = (x, g) -> quadratic!(x, g, AtA, A'*b, tmp)
-        objective = Optim.DifferentiableFunction(x->func(x, nothing), (x,g)->func(x,g), func)
+        objective = Optim.OnceDifferentiable(x->func(x, nothing), (x,g)->func(x,g), func)
         results = Optim.optimize(objective, initial_x, ConjugateGradient())
         results = Optim.optimize(objective, Optim.minimizer(results), ConjugateGradient())  # restart to ensure high-precision convergence
         @test Optim.converged(results)

test/extrapolate.jl

@@ -30,7 +30,7 @@ import LineSearches
     precond(x::Vector) = precond(length(x))
     precond(n::Number) = spdiagm(( -ones(n-1), 2*ones(n), -ones(n-1) ),
                          (-1,0,1), n, n) * (n+1)
-    df = DifferentiableFunction( X->plap([0;X;0]),
+    df = OnceDifferentiable( X->plap([0;X;0]),
                                 (X, G)->copy!(G, (plap1([0;X;0]))[2:end-1]) )
     GRTOL = 1e-6
     N = 100

test/gradient_descent.jl

@@ -28,7 +28,7 @@
 
     initial_x = [0.0]
 
-    d = DifferentiableFunction(f_gd_1, g_gd_1)
+    d = OnceDifferentiable(f_gd_1, g_gd_1)
 
     results = Optim.optimize(d, initial_x, GradientDescent())
     @test_throws ErrorException Optim.x_trace(results)
@@ -46,7 +46,7 @@
       storage[2] = eta * x[2]
     end
 
-    d = DifferentiableFunction(f_gd_2, g_gd_2)
+    d = OnceDifferentiable(f_gd_2, g_gd_2)
 
     results = Optim.optimize(d, [1.0, 1.0], GradientDescent())
     @test_throws ErrorException Optim.x_trace(results)