Add MadNCL solver to registry and methods

- Add CTSolvers.MadNCL to strategy registry
- Add MadNCL variants to methods() function
- Update tests to expect 4 solvers (Ipopt, MadNLP, MadNCL, Knitro)
- Update tests to expect 8 total methods (2 modelers × 4 solvers)
- Fix docstring examples to reflect new counts
- All tests passing (25/25)

MadNCL extends solver options for linear constraints handling.

Author: ocots

src/helpers/methods.jl

@@ -17,7 +17,7 @@ julia> m = methods()
 ((:collocation, :adnlp, :ipopt), (:collocation, :adnlp, :madnlp), ...)
 
 julia> length(m)
-6
+8
 ```
 
 # See Also
@@ -30,6 +30,8 @@ function Base.methods()::Tuple{Vararg{Tuple{Symbol, Symbol, Symbol}}}
         (:collocation, :adnlp, :madnlp),
         (:collocation, :exa,   :ipopt ),
         (:collocation, :exa,   :madnlp),
+        (:collocation, :adnlp, :madncl),
+        (:collocation, :exa,   :madncl),
         (:collocation, :adnlp, :knitro),
         (:collocation, :exa,   :knitro),
     )

src/helpers/registry.jl

@@ -9,23 +9,16 @@ The registry maps abstract strategy families to their concrete implementations:
 - `CTSolvers.AbstractNLPSolver` → NLP solver strategies
 
 # Returns
-- `CTSolvers.Strategies.StrategyRegistry`: Registry with all available strategies
+- `CTSolvers.StrategyRegistry`: Registry with all available strategies
 
 # Examples
 ```julia
-julia> registry = get_strategy_registry()
+julia> registry = OptimalControl.get_strategy_registry()
 StrategyRegistry with 3 families
-
-julia> CTSolvers.Strategies.strategy_ids(CTDirect.AbstractDiscretizer, registry)
-(:collocation,)
 ```
-
-# See Also
-- [`CTSolvers.Strategies.create_registry`](@ref): Creates a strategy registry
-- [`CTSolvers.Strategies.StrategyRegistry`](@ref): Registry type
 """
-function get_strategy_registry()::CTSolvers.Strategies.StrategyRegistry
-    return CTSolvers.Strategies.create_registry(
+function get_strategy_registry()::CTSolvers.StrategyRegistry
+    return CTSolvers.create_registry(
         CTDirect.AbstractDiscretizer => (
             CTDirect.Collocation,
             # Add other discretizers as they become available
@@ -37,6 +30,7 @@ function get_strategy_registry()::CTSolvers.Strategies.StrategyRegistry
         CTSolvers.AbstractNLPSolver => (
             CTSolvers.Ipopt,
             CTSolvers.MadNLP,
+            CTSolvers.MadNCL,
             CTSolvers.Knitro,
         )
     )

test/suite/helpers/test_methods.jl

@@ -24,11 +24,13 @@ function test_methods()
 
             Test.@test (:collocation, :adnlp, :ipopt) in methods
             Test.@test (:collocation, :adnlp, :madnlp) in methods
+            Test.@test (:collocation, :adnlp, :madncl) in methods
             Test.@test (:collocation, :adnlp, :knitro) in methods
             Test.@test (:collocation, :exa, :ipopt) in methods
             Test.@test (:collocation, :exa, :madnlp) in methods
+            Test.@test (:collocation, :exa, :madncl) in methods
             Test.@test (:collocation, :exa, :knitro) in methods
-            Test.@test length(methods) == 6
+            Test.@test length(methods) == 8
         end
 
         Test.@testset "Uniqueness" begin

test/suite/helpers/test_registry.jl

@@ -4,6 +4,7 @@ using Test
 import OptimalControl
 import CTSolvers
 import CTDirect
+
 const VERBOSE = isdefined(Main, :TestOptions) ? Main.TestOptions.VERBOSE : true
 const SHOWTIMING = isdefined(Main, :TestOptions) ? Main.TestOptions.SHOWTIMING : true
 
@@ -16,38 +17,39 @@ function test_registry()
 
         @testset "Registry Creation" begin
             registry = OptimalControl.get_strategy_registry()
-            @test registry isa CTSolvers.Strategies.StrategyRegistry
+            @test registry isa CTSolvers.StrategyRegistry
         end
 
         @testset "Discretizer Family" begin
             registry = OptimalControl.get_strategy_registry()
-            ids = CTSolvers.Strategies.strategy_ids(CTDirect.AbstractDiscretizer, registry)
+            ids = CTSolvers.strategy_ids(CTDirect.AbstractDiscretizer, registry)
             @test :collocation in ids
             @test length(ids) >= 1
         end
 
         @testset "Modeler Family" begin
             registry = OptimalControl.get_strategy_registry()
-            ids = CTSolvers.Strategies.strategy_ids(CTSolvers.AbstractNLPModeler, registry)
+            ids = CTSolvers.strategy_ids(CTSolvers.AbstractNLPModeler, registry)
             @test :adnlp in ids
             @test :exa in ids
             @test length(ids) == 2
         end
 
         @testset "Solver Family" begin
             registry = OptimalControl.get_strategy_registry()
-            ids = CTSolvers.Strategies.strategy_ids(CTSolvers.AbstractNLPSolver, registry)
+            ids = CTSolvers.strategy_ids(CTSolvers.AbstractNLPSolver, registry)
             @test :ipopt in ids
             @test :madnlp in ids
+            @test :madncl in ids
             @test :knitro in ids
-            @test length(ids) == 3
+            @test length(ids) == 4
         end
 
         @testset "Determinism" begin
             r1 = OptimalControl.get_strategy_registry()
             r2 = OptimalControl.get_strategy_registry()
-            ids1 = CTSolvers.Strategies.strategy_ids(CTSolvers.AbstractNLPSolver, r1)
-            ids2 = CTSolvers.Strategies.strategy_ids(CTSolvers.AbstractNLPSolver, r2)
+            ids1 = CTSolvers.strategy_ids(CTSolvers.AbstractNLPSolver, r1)
+            ids2 = CTSolvers.strategy_ids(CTSolvers.AbstractNLPSolver, r2)
             @test ids1 == ids2
         end
     end