sem_optimizer_subtype(engine)

internal method returning the type that implements SemOptimizer{engine}

Author: Alexey Stukalov

docs/src/developer/optimizer.md

@@ -1,6 +1,6 @@
 # Custom optimizer types
 
-The optimizer part of a model connects it to the optimization backend. 
+The optimizer part of a model connects it to the optimization backend.
 Let's say we want to implement a new optimizer as `SemOptimizerName`. The first part of the implementation is very similar to loss functions, so we just show the implementation of `SemOptimizerOptim` here as a reference:
 
 ```julia
@@ -12,7 +12,7 @@ mutable struct SemOptimizerName{A, B} <: SemOptimizer{:Name}
     options::B
 end
 
-SemOptimizer{:Name}(args...; kwargs...) = SemOptimizerName(args...; kwargs...)
+SEM.sem_optimizer_subtype(::Val{:Name}) = SemOptimizerName
 
 SemOptimizerName(;
     algorithm = LBFGS(),

ext/SEMNLOptExt/NLopt.jl

@@ -85,6 +85,8 @@ struct SemOptimizerNLopt <: SemOptimizer{:NLopt}
     inequality_constraints::Vector{NLoptConstraint}
 end
 
+SEM.sem_optimizer_subtype(::Val{:NLopt}) = SemOptimizerNLopt
+
 ############################################################################################
 ### Constructor
 ############################################################################################
@@ -117,8 +119,6 @@ function SemOptimizerNLopt(;
     )
 end
 
-SEM.SemOptimizer{:NLopt}(args...; kwargs...) = SemOptimizerNLopt(args...; kwargs...)
-
 ############################################################################################
 ### Recommended methods
 ############################################################################################

ext/SEMProximalOptExt/ProximalAlgorithms.jl

@@ -30,15 +30,15 @@ mutable struct SemOptimizerProximal{A, B, C} <: SemOptimizer{:Proximal}
     operator_h::C
 end
 
-SEM.SemOptimizer{:Proximal}(args...; kwargs...) = SemOptimizerProximal(args...; kwargs...)
-
 SemOptimizerProximal(;
     algorithm = ProximalAlgorithms.PANOC(),
     operator_g,
     operator_h = nothing,
     kwargs...,
 ) = SemOptimizerProximal(algorithm, operator_g, operator_h)
 
+SEM.sem_optimizer_subtype(::Val{:Proximal}) = SemOptimizerProximal
+
 ############################################################################################
 ### Recommended methods
 ############################################################################################

src/optimizer/Empty.jl

@@ -11,11 +11,7 @@ an optimizer part.
 """
 struct SemOptimizerEmpty <: SemOptimizer{:Empty} end
 
-############################################################################################
-### Constructor
-############################################################################################
-
-SemOptimizer{:Empty}() = SemOptimizerEmpty()
+sem_optimizer_subtype(::Val{:Empty}) = SemOptimizerEmpty
 
 ############################################################################################
 ### Recommended methods

src/optimizer/abstract.jl

@@ -1,17 +1,32 @@
-SemOptimizer(args...; engine::Symbol = :Optim, kwargs...) =
-    SemOptimizer{engine}(args...; kwargs...)
-
-# fallback optimizer constructor
-function SemOptimizer{E}(args...; kwargs...) where {E}
-    if E == :NLOpt
+# throw unsupported engine error
+function throw_engine_error(E)
+    if typeof(E) !== Symbol
+        throw(ArgumentError("engine argument must be a Symbol."))
+    elseif E == :NLopt
         error("$E optimizer requires \"using NLopt\".")
     elseif E == :Proximal
         error("$E optimizer requires \"using ProximalAlgorithms\".")
     else
-        error("$E optimizer is not supported.")
+        error("$E optimizer engine is not supported.")
     end
 end
 
+# return the type implementing SemOptimizer{engine}
+# the method should be overridden in the extension
+sem_optimizer_subtype(engine::Symbol) = sem_optimizer_subtype(Val(engine))
+
+# fallback method for unsupported engines
+sem_optimizer_subtype(::Val{E}) where {E} = throw_engine_error(E)
+
+# default constructor that dispatches to the engine-specific type
+SemOptimizer(::Val{E}, args...; kwargs...) where {E} =
+    sem_optimizer_subtype(E)(args...; kwargs...)
+
+SemOptimizer{E}(args...; kwargs...) where {E} = SemOptimizer(Val(E), args...; kwargs...)
+
+SemOptimizer(args...; engine::Symbol = :Optim, kwargs...) =
+    SemOptimizer(Val(engine), args...; kwargs...)
+
 """
     optimizer_engine(::Type{<:SemOptimizer})
     optimizer_engine(::SemOptimizer)

src/optimizer/optim.jl

@@ -63,14 +63,14 @@ mutable struct SemOptimizerOptim{A, B} <: SemOptimizer{:Optim}
     options::B
 end
 
-SemOptimizer{:Optim}(args...; kwargs...) = SemOptimizerOptim(args...; kwargs...)
-
 SemOptimizerOptim(;
     algorithm = LBFGS(),
     options = Optim.Options(; f_reltol = 1e-10, x_abstol = 1.5e-8),
     kwargs...,
 ) = SemOptimizerOptim(algorithm, options)
 
+sem_optimizer_subtype(::Val{:Optim}) = SemOptimizerOptim
+
 ############################################################################################
 ### Recommended methods
 ############################################################################################