Update Uno to support ExaModels modeler

- Add (:collocation, :exa, :uno, :cpu) method to available methods
- Update tests to include Uno with Exa modeler (8 combinations total)
- Update method counts: 10 CPU methods + 2 GPU methods = 12 total
- Update CHANGELOG to reflect Uno works with both ADNLP and Exa
- Remove ADNLP-only restriction from documentation

Author: ocots

CHANGELOG.md

@@ -13,8 +13,8 @@ Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - **Uno solver integration**: Full support for the Uno nonlinear optimization solver
   - Added to solver registry with CPU-only support
-  - Added method `(:collocation, :adnlp, :uno, :cpu)` to available methods
-  - Uno only compatible with ADNLP modeler (not ExaModels)
+  - Added methods `(:collocation, :adnlp, :uno, :cpu)` and `(:collocation, :exa, :uno, :cpu)` to available methods
+  - Uno compatible with both ADNLP and Exa modelers
   - Comprehensive test coverage with Beam and Goddard problems
   - Extension error handling when `UnoSolver` package not loaded
 
@@ -34,8 +34,8 @@ Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ### Changed
 
 - **Solver count**: Updated from 4 to 5 available solvers (Ipopt, MadNLP, Uno, MadNCL, Knitro)
-- **Method count**: Updated from 10 to 11 available methods (9 CPU + 2 GPU)
-- **Test structure**: Restructured canonical tests to use modeler-solver pairs, respecting Uno/ADNLP-only constraint
+- **Method count**: Updated from 10 to 12 available methods (10 CPU + 2 GPU)
+- **Test structure**: Restructured canonical tests to use modeler-solver pairs, Uno now works with both ADNLP and Exa
 - **Documentation**: Updated solver lists and examples throughout documentation to include Uno
 
 ---

docs/src/manual-solve.md

@@ -100,9 +100,9 @@ Each method is a **quadruplet** `(discretizer, modeler, solver, parameter)`:
    - `:exa`: uses [`ExaModels.ExaModel`](@extref) with SIMD optimization (GPU-capable)
 
 3. **Solver** — which NLP solver to use:
-   - `:ipopt`: [Ipopt](https://coin-or.github.io/Ipopt/) interior point solver
+   - `:ipopt`: [Ipopt](https://coin-or.github.io/Ipopt/) interior point solver (CPU-only)
    - `:madnlp`: [MadNLP](https://madnlp.github.io/MadNLP.jl/) pure-Julia solver (GPU-capable)
-   - `:uno`: [Uno](https://unosolver.readthedocs.io) unified nonlinear optimization solver (CPU-only, ADNLP-only)
+   - `:uno`: [Uno](https://unosolver.readthedocs.io) unified nonlinear optimization solver (CPU-only)
    - `:madncl`: [MadNCL](https://github.com/MadNLP/MadNCL.jl) (GPU-capable)
    - `:knitro`: [Knitro](https://www.artelys.com/solvers/knitro/) commercial solver (license required)
 

src/helpers/methods.jl

@@ -49,6 +49,7 @@ function Base.methods()::Tuple{Vararg{Tuple{Symbol,Symbol,Symbol,Symbol}}}
         (:collocation, :adnlp, :knitro, :cpu),
         (:collocation, :exa, :ipopt, :cpu),
         (:collocation, :exa, :madnlp, :cpu),
+        (:collocation, :exa, :uno, :cpu),
         (:collocation, :exa, :madncl, :cpu),
         (:collocation, :exa, :knitro, :cpu),
 

test/suite/helpers/test_methods.jl

@@ -37,15 +37,16 @@ function test_methods()
             Test.@test (:collocation, :adnlp, :knitro, :cpu) in methods
             Test.@test (:collocation, :exa, :ipopt, :cpu) in methods
             Test.@test (:collocation, :exa, :madnlp, :cpu) in methods
+            Test.@test (:collocation, :exa, :uno, :cpu) in methods
             Test.@test (:collocation, :exa, :madncl, :cpu) in methods
             Test.@test (:collocation, :exa, :knitro, :cpu) in methods
 
             # GPU methods (new functionality)
             Test.@test (:collocation, :exa, :madnlp, :gpu) in methods
             Test.@test (:collocation, :exa, :madncl, :gpu) in methods
 
-            # Total count: 9 CPU methods + 2 GPU methods = 11 methods
-            Test.@test length(methods) == 11
+            # Total count: 10 CPU methods + 2 GPU methods = 12 methods
+            Test.@test length(methods) == 12
         end
 
         Test.@testset "Parameter Distribution" begin
@@ -55,7 +56,7 @@ function test_methods()
             cpu_methods = filter(m -> m[4] == :cpu, methods)
             gpu_methods = filter(m -> m[4] == :gpu, methods)
 
-            Test.@test length(cpu_methods) == 9  # All original methods now with :cpu + Uno
+            Test.@test length(cpu_methods) == 10  # All original methods now with :cpu + Uno
             Test.@test length(gpu_methods) == 2  # Only GPU-capable combinations
         end
 
@@ -175,8 +176,8 @@ function test_methods()
                 gpu_methods = filter(m -> m[4] == :gpu, methods)
 
                 # CPU methods should include all combinations except GPU-only
-                Test.@test length(cpu_methods) == 9
-                Test.@test length(gpu_methods) == 2
+                Test.@test length(cpu_methods) == 10  # All original methods now with :cpu + Uno
+                Test.@test length(gpu_methods) == 2  # Only GPU-capable combinations
 
                 # Total should match expected
                 Test.@test length(methods) == length(cpu_methods) + length(gpu_methods)

test/suite/solve/test_canonical.jl

@@ -63,16 +63,17 @@ function test_canonical()
             ),
         ]
 
-        # Define modeler-solver pairs (Uno only works with ADNLP)
+        # Define modeler-solver pairs (Uno works with both ADNLP and Exa)
         modeler_solver_pairs = [
             # ADNLP modeler with all solvers
             ("ADNLP", "Ipopt", OptimalControl.ADNLP(), OptimalControl.Ipopt(print_level=0)),
             ("ADNLP", "MadNLP", OptimalControl.ADNLP(), OptimalControl.MadNLP(print_level=MadNLP.ERROR)),
             ("ADNLP", "Uno", OptimalControl.ADNLP(), OptimalControl.Uno(logger="SILENT")),
             ("ADNLP", "MadNCL", OptimalControl.ADNLP(), OptimalControl.MadNCL(print_level=MadNLP.ERROR)),
-            # Exa modeler with all solvers except Uno
+            # Exa modeler with all solvers
             ("Exa", "Ipopt", OptimalControl.Exa(), OptimalControl.Ipopt(print_level=0)),
             ("Exa", "MadNLP", OptimalControl.Exa(), OptimalControl.MadNLP(print_level=MadNLP.ERROR)),
+            ("Exa", "Uno", OptimalControl.Exa(), OptimalControl.Uno(logger="SILENT")),
             ("Exa", "MadNCL", OptimalControl.Exa(), OptimalControl.MadNCL(print_level=MadNLP.ERROR)),
         ]