Adapt Particle Swarm state.

Author: kellertuer

src/solvers/particle_swarm.jl

@@ -48,72 +48,72 @@ $(_kwargs(:vector_transport_method))
 [`particle_swarm`](@ref)
 """
 mutable struct ParticleSwarmState{
-        P,
-        T,
-        TX <: AbstractVector{P},
-        TVelocity <: AbstractVector{T},
-        TParams <: Real,
-        TStopping <: StoppingCriterion,
-        TRetraction <: AbstractRetractionMethod,
-        TInvRetraction <: AbstractInverseRetractionMethod,
-        TVTM <: AbstractVectorTransportMethod,
+        P, T, F <: Real, VP <: AbstractVector{P}, VT <: AbstractVector{T},
+        SC <: StoppingCriterion, RM <: AbstractRetractionMethod,
+        IRM <: AbstractInverseRetractionMethod, VTM <: AbstractVectorTransportMethod,
     } <: AbstractManoptSolverState
-    swarm::TX
-    positional_best::TX
+    swarm::VP
+    positional_best::VP
     p::P
-    velocity::TVelocity
-    inertia::TParams
-    social_weight::TParams
-    cognitive_weight::TParams
+    velocity::VT
+    inertia::F
+    social_weight::F
+    cognitive_weight::F
     q::P
     social_vector::T
     cognitive_vector::T
-    stop::TStopping
-    retraction_method::TRetraction
-    inverse_retraction_method::TInvRetraction
-    vector_transport_method::TVTM
-
+    stop::SC
+    retraction_method::RM
+    inverse_retraction_method::IRM
+    vector_transport_method::VTM
+    function ParticleSwarmState(;
+            swarm::VP, positional_best::VP, p::P, velocity::VT,
+            inertia::F, social_weight::F, cognitive_weight::F, q::P, social_vector::T,
+            cognitive_vector::T, stopping_criterion::SC, retraction_method::RM,
+            inverse_retraction_method::IRM, vector_transport_method::VTM
+        ) where {
+            P, T, F, VP <: AbstractVector, VT <: AbstractVector, SC <: StoppingCriterion,
+            RM <: AbstractRetractionMethod, IRM <: AbstractInverseRetractionMethod, VTM <: AbstractVectorTransportMethod,
+        }
+        return new{P, T, F, VP, VT, SC, RM, IRM, VTM}(
+            swarm, positional_best, p, velocity, inertia, social_weight, cognitive_weight, q,
+            social_vector, cognitive_vector, stopping_criterion, retraction_method,
+            inverse_retraction_method, vector_transport_method
+        )
+    end
     function ParticleSwarmState(
-            M::AbstractManifold,
-            swarm::VP,
-            velocity::VT;
-            inertia = 0.65,
-            social_weight = 1.4,
-            cognitive_weight = 1.4,
+            M::AbstractManifold, swarm::VP, velocity::VT;
+            inertia::Real = 0.65, social_weight::Real = 1.4, cognitive_weight::Real = 1.4,
             stopping_criterion::SCT = StopAfterIteration(500) | StopWhenChangeLess(M, 1.0e-4),
             retraction_method::RTM = default_retraction_method(M, eltype(swarm)),
             inverse_retraction_method::IRM = default_inverse_retraction_method(M, eltype(swarm)),
             vector_transport_method::VTM = default_vector_transport_method(M, eltype(swarm)),
         ) where {
-            P,
-            T,
-            VP <: AbstractVector{<:P},
-            VT <: AbstractVector{<:T},
-            RTM <: AbstractRetractionMethod,
-            SCT <: StoppingCriterion,
-            IRM <: AbstractInverseRetractionMethod,
-            VTM <: AbstractVectorTransportMethod,
+            P, T, VP <: AbstractVector{<:P}, VT <: AbstractVector{<:T},
+            RTM <: AbstractRetractionMethod, SCT <: StoppingCriterion,
+            IRM <: AbstractInverseRetractionMethod, VTM <: AbstractVectorTransportMethod,
         }
-        s = new{
-            P, T, VP, VT, typeof(inertia + social_weight + cognitive_weight), SCT, RTM, IRM, VTM,
-        }()
-        s.swarm = swarm
-        s.positional_best = copy.(Ref(M), swarm)
-        s.q = copy(M, first(swarm))
-        s.p = copy(M, first(swarm))
-        s.social_vector = zero_vector(M, s.q)
-        s.cognitive_vector = zero_vector(M, s.q)
-        s.velocity = velocity
-        s.inertia = inertia
-        s.social_weight = social_weight
-        s.cognitive_weight = cognitive_weight
-        s.stop = stopping_criterion
-        s.retraction_method = retraction_method
-        s.inverse_retraction_method = inverse_retraction_method
-        s.vector_transport_method = vector_transport_method
-        return s
+        R = promote_type(typeof(inertia), typeof(social_weight), typeof(cognitive_weight))
+        inertia = convert(R, inertia); social_weight = convert(R, social_weight); cognitive_weight = convert(R, cognitive_weight)
+        return ParticleSwarmState(;
+            swarm = swarm, positional_best = copy.(Ref(M), swarm),
+            q = copy(M, first(swarm)), p = copy(M, first(swarm)),
+            social_vector = zero_vector(M, first(swarm)), cognitive_vector = zero_vector(M, first(swarm)),
+            velocity = velocity, inertia = inertia, social_weight = social_weight, cognitive_weight = cognitive_weight,
+            stopping_criterion = stopping_criterion, retraction_method = retraction_method,
+            inverse_retraction_method = inverse_retraction_method, vector_transport_method = vector_transport_method
+        )
     end
 end
+function Base.show(io::IO, pss::ParticleSwarmState)
+    print(io, "ParticleSwarmState(; swarm = ", pss.swarm, ", positional_best = ", pss.positional_best)
+    print(io, ", p = ", pss.p, ", velocity = ", pss.velocity)
+    print(io, ", inertia = ", pss.inertia, ", social_weight = ", pss.social_weight, ", cognitive_weight = ", pss.cognitive_weight)
+    print(io, ", q = ", pss.q, ", social_vector = ", pss.social_vector, ", cognitive_vector = ", pss.cognitive_vector)
+    print(io, ", stopping_criterion = ", pss.stop, ", retraction_method = ", pss.retraction_method)
+    print(io, ", inverse_retraction_method = ", pss.inverse_retraction_method, ", vector_transport_method = ", pss.vector_transport_method)
+    return print(io, ")")
+end
 function status_summary(pss::ParticleSwarmState; context::Symbol = :default)
     (context === :short) && return repr(pss)
     i = get_count(pss, :Iterations)
@@ -303,16 +303,10 @@ function particle_swarm!(
     dmco = decorate_objective!(M, mco; kwargs...)
     mp = DefaultManoptProblem(M, dmco)
     pss = ParticleSwarmState(
-        M,
-        swarm,
-        velocity;
-        inertia = inertia,
-        social_weight = social_weight,
-        cognitive_weight = cognitive_weight,
-        stopping_criterion = stopping_criterion,
-        retraction_method = retraction_method,
-        inverse_retraction_method = inverse_retraction_method,
-        vector_transport_method = vector_transport_method,
+        M, swarm, velocity;
+        inertia = inertia, social_weight = social_weight, cognitive_weight = cognitive_weight,
+        stopping_criterion = stopping_criterion, retraction_method = retraction_method,
+        inverse_retraction_method = inverse_retraction_method, vector_transport_method = vector_transport_method,
     )
     dpss = decorate_state!(pss; kwargs...)
     solve!(mp, dpss)
@@ -333,11 +327,7 @@ function step_solver!(mp::AbstractManoptProblem, s::ParticleSwarmState, ::Any)
     M = get_manifold(mp)
     for i in 1:length(s.swarm)
         inverse_retract!(
-            M,
-            s.cognitive_vector,
-            s.swarm[i],
-            s.positional_best[i],
-            s.inverse_retraction_method,
+            M, s.cognitive_vector, s.swarm[i], s.positional_best[i], s.inverse_retraction_method,
         )
         inverse_retract!(M, s.social_vector, s.swarm[i], s.p, s.inverse_retraction_method)
         s.velocity[i] .=

test/solvers/test_particle_swarm.jl

@@ -15,6 +15,7 @@ using Random
             Manopt.status_summary(o; context = :default),
             "# Solver state for `Manopt.jl`s Particle Swarm Optimization Algorithm\n"
         )
+        @test startswith(repr(o), "ParticleSwarmState(;")
         g = get_solver_result(o)
 
         initF = min(f.(Ref(M), p1)...)