Loosen Vector to Array to allow optimization of functions of Arrays

JuliaNLSolvers · Mar 7, 2014 · 47a39d2 · 47a39d2
1 parent 007dc77
commit 47a39d2
Show file tree

Hide file tree

Showing 5 changed files with 39 additions and 23 deletions.
diff --git a/src/linesearch/hz_linesearch.jl b/src/linesearch/hz_linesearch.jl
@@ -69,7 +69,7 @@ const DEFAULTSIGMA = 0.9
 # Generate initial guess for step size (HZ, stage I0)
 function alphainit{T}(alpha::Real,
                       x::Array{T},
-                      gr::Vector, # Could loosen to Array
+                      gr::Array,
                       f_x::Real,
                       psi0::T = 0.01)
     if isnan(alpha)
@@ -92,10 +92,10 @@ end
 function alphatry{T}(alpha::T,
                      d::Union(DifferentiableFunction,
                               TwiceDifferentiableFunction),
-                     x::Vector,
-                     s::Vector,
-                     xtmp::Vector,
-                     gtmp::Vector,
+                     x::Array,
+                     s::Array,
+                     xtmp::Array,
+                     gtmp::Array,
                      lsr::LineSearchResults,
                      psi1::Real = 0.2,
                      psi2::Real = 2,
@@ -167,10 +167,10 @@ end
 
 function hz_linesearch!{T}(df::Union(DifferentiableFunction,
                                      TwiceDifferentiableFunction),
-                           x::Vector{T},
-                           s::Vector,
-                           xtmp::Vector,
-                           g::Vector,
+                           x::Array{T},
+                           s::Array,
+                           xtmp::Array,
+                           g::Array,
                            lsr::LineSearchResults{T},
                            c::Real,
                            mayterminate::Bool,
@@ -605,11 +605,11 @@ end
 # Define one-parameter function for line searches
 function linefunc!(df::Union(DifferentiableFunction,
                             TwiceDifferentiableFunction),
-                   x::Vector,
-                   s::Vector,
+                   x::Array,
+                   s::Array,
                    alpha::Real,
-                   xtmp::Vector,
-                   g::Vector,
+                   xtmp::Array,
+                   g::Array,
                    calc_grad::Bool)
     f_calls = 0
     g_calls = 0

diff --git a/src/types.jl b/src/types.jl
@@ -21,10 +21,10 @@ OptimizationTrace() = OptimizationTrace(Array(OptimizationState, 0))
 
 abstract OptimizationResults
 
-type MultivariateOptimizationResults{T} <: OptimizationResults
+type MultivariateOptimizationResults{T,N} <: OptimizationResults
     method::ASCIIString
-    initial_x::Vector{T}
-    minimum::Vector{T}
+    initial_x::Array{T,N}
+    minimum::Array{T,N}
     f_minimum::Float64
     iterations::Int
     iteration_converged::Bool
@@ -104,19 +104,19 @@ end
 
 # TODO: Expose ability to do forward and backward differencing
 function DifferentiableFunction(f::Function)
-    function g!(x::Vector, storage::Vector)
+    function g!(x::Array, storage::Array)
         Calculus.finite_difference!(f, x, storage, :central)
         return
     end
-    function fg!(x::Vector, storage::Vector)
+    function fg!(x::Array, storage::Array)
         g!(x, storage)
         return f(x)
     end
     return DifferentiableFunction(f, g!, fg!)
 end
 
 function DifferentiableFunction(f::Function, g!::Function)
-    function fg!(x::Vector, storage::Vector)
+    function fg!(x::Array, storage::Array)
         g!(x, storage)
         return f(x)
     end

diff --git a/src/utilities/assess_convergence.jl b/src/utilities/assess_convergence.jl
@@ -1,8 +1,8 @@
-function assess_convergence(x::Vector,
-                            x_previous::Vector,
+function assess_convergence(x::Array,
+                            x_previous::Array,
                             f_x::Real,
                             f_x_previous::Real,
-                            gr::Vector,
+                            gr::Array,
                             xtol::Real,
                             ftol::Real,
                             grtol::Real)

diff --git a/src/utilities/maxdiff.jl b/src/utilities/maxdiff.jl
@@ -1,4 +1,4 @@
-function maxdiff(x::Vector, y::Vector)
+function maxdiff(x::Array, y::Array)
     res = 0.0
     for i in 1:length(x)
         delta = abs(x[i] - y[i])

diff --git a/test/cg.jl b/test/cg.jl
@@ -12,3 +12,19 @@ for (name, prob) in Optim.UnconstrainedProblems.examples
 		end
 	end
 end
+
+let
+objective(X, B) = sum((X.-B).^2)/2
+
+function objective_gradient!(X, G, B)
+    for i = 1:length(G)
+        G[i] = X[i]-B[i]
+    end
+end
+
+B = rand(2,2)
+df = Optim.DifferentiableFunction(X -> objective(X, B), (X, G) -> objective_gradient!(X, G, B))
+results = Optim.cg(df, rand(2,2))
+@assert Optim.converged(results)
+@assert results.f_minimum < 1e-8
+end