Pass return_state and add spd test

Author: Vaibhavdixit02

lib/OptimizationManopt/src/OptimizationManopt.jl

@@ -47,12 +47,12 @@ function call_manopt_optimizer(opt::GradientDescentOptimizer{Teval},
                             loss,
                             gradF,
                             x0;
-                            return_options = true,
+                            return_state = true,
                             evaluation = Teval(),
                             stepsize = opt.stepsize,
                             sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = opts
+    minimizer = Manopt.get_solver_result(opts)
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -78,9 +78,9 @@ function call_manopt_optimizer(opt::NelderMeadOptimizer,
 
     opts = NelderMead(opt.M,
                       loss;
-                      return_options = true,
+                      return_state = true,
                       sckwarg...)
-    minimizer = opts
+    minimizer = Manopt.get_solver_result(opts)
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -114,12 +114,12 @@ function call_manopt_optimizer(opt::ConjugateGradientDescentOptimizer{Teval},
                                       loss,
                                       gradF,
                                       x0;
-                                      return_options = true,
+                                      return_state = true,
                                       evaluation = Teval(),
                                       stepsize = opt.stepsize,
                                       sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = opts
+    minimizer = Manopt.get_solver_result(opts)
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -167,13 +167,13 @@ function call_manopt_optimizer(opt::ParticleSwarmOptimizer{Teval},
                           loss;
                           x0 = initial_population,
                           n = opt.population_size,
-                          return_options = true,
+                          return_state = true,
                           retraction_method = opt.retraction_method,
                           inverse_retraction_method = opt.inverse_retraction_method,
                           vector_transport_method = opt.vector_transport_method,
                           sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = opts
+    minimizer = Manopt.get_solver_result(opts)
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end
@@ -218,14 +218,14 @@ function call_manopt_optimizer(opt::QuasiNewtonOptimizer{Teval},
                                       loss,
                                       gradF,
                                       x0;
-                                      return_options = true,
+                                      return_state = true,
                                       evaluation = Teval(),
                                       retraction_method = opt.retraction_method,
                                       vector_transport_method = opt.vector_transport_method,
                                       stepsize = opt.stepsize,
                                       sckwarg...)
     # we unwrap DebugOptions here
-    minimizer = opts
+    minimizer = Manopt.get_solver_result(opts)
     return (; minimizer = minimizer, minimum = loss(opt.M, minimizer), options = opts),
            :who_knows
 end

lib/OptimizationManopt/test/runtests.jl

@@ -1,10 +1,11 @@
 using OptimizationManopt
 using Optimization
 using Manifolds
-using ForwardDiff
+using ForwardDiff, Zygote, Enzyme
 using Manopt
 using Test
 using Optimization.SciMLBase
+using LinearAlgebra
 
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
 
@@ -98,4 +99,23 @@ end
     optprob_cons = OptimizationFunction(rosenbrock; grad = rosenbrock_grad!, cons = cons)
     prob_cons = OptimizationProblem(optprob_cons, x0, p)
     @test_throws SciMLBase.IncompatibleOptimizerError Optimization.solve(prob_cons, opt)
+end
+
+@testset "SPD Manifold" begin
+    M = SymmetricPositiveDefinite(5)
+    m = 100
+    σ = 0.005
+    q = Matrix{Float64}(I, 5, 5) .+ 2.0
+    data2 = [exp(M, q, σ * rand(M; vector_at=q)) for i in 1:m];
+
+    f(M, x, p = nothing) = sum(distance(M, x, data2[i])^2 for i in 1:m)
+    f(x, p = nothing) = sum(distance(M, x, data2[i])^2 for i in 1:m)
+
+    optf = OptimizationFunction(f, Optimization.AutoForwardDiff())
+    prob = OptimizationProblem(optf, data2[1])
+
+    opt = OptimizationManopt.GradientDescentOptimizer(M)
+    @time sol = Optimization.solve(prob, opt)
+
+    @test sol.u ≈ q
 end