feat(jump): can use solver from jump

Integration from jump seems to work for very simple example

Author: gkantsidis

.vscode/settings.json

@@ -24,6 +24,7 @@
         "CUDA",
         "CUSPARSE",
         "deploydocs",
+        "diagind",
         "eigmax",
         "ENDATA",
         "eprint",
@@ -48,6 +49,7 @@
         "mathbb",
         "mathbf",
         "mathengine",
+        "maxcut",
         "Mersenne",
         "Mohseni",
         "MOIU",

docs/src/reference/reference.md

@@ -3,6 +3,7 @@ CurrentModule = AOCoptimizer
 DocTestSetup = quote
     import AOCoptimizer as AOC
     import AOCoptimizer.Solver as Solver
+    import AOCoptimizer.api as API
 end
 DocTestFilters = [r"AOCoptimizer|AOC"]
 ```
@@ -355,3 +356,40 @@ Solver._optimal_batch_size
 ```@docs
 Solver.Collector._default_best_assignment_collector
 ```
+
+## `API`
+
+The `AOCoptimizer.api` module contains simplified (and rigid) interfaces to the solver.
+They're easier to use than the normal interfaces, but they don't give access to most configuration parameters.
+
+```@docs
+api.adjust_inputs_to_engine
+```
+
+```@docs
+api.GraphCutResult
+```
+
+```@docs
+api.compute_max_cut
+```
+
+```@docs
+api.IsingResult
+```
+
+```@docs
+api.compute_ising
+```
+
+```@docs
+api.compute_mixed_ising
+```
+
+```@docs
+api.compute_qumo_positive
+```
+
+```@docs
+api.compute_qumo
+```

ext/CUDAExt/CUDAExt.jl

@@ -157,4 +157,30 @@ AOCoptimizer.Solver._similar_vector(x::CuSparseMatrix, l) = CuVector{eltype(x)}(
 
 include("engine.jl")
 
+function AOCoptimizer.api.adjust_inputs_to_engine(
+    ::AOCoptimizer.Solver.EngineCuda,
+    matrix::AbstractMatrix{T},
+    linear::Union{Nothing,AbstractVector{T}} = nothing,
+) where T<:Real
+    version = CUDA.capability(dev.dev)
+
+    if version < v"5.3" && T === Float16
+        @warn "Computing with Float16 on a GPU with compute capability less than 5.3 is not supported. Switching to Float32."
+        if linear !== nothing
+            linear = Float32.(linear)
+        end
+        return Float32, Float32.(matrix), linear
+    end
+
+    if version < v"8.0" && T === BFloat16
+        @warn "Computing with BFloat16 on a GPU with compute capability less than 8.0 is not supported. Switching to Float32."
+        if linear !== nothing
+            linear = Float32.(linear)
+        end
+        return Float32, Float32.(matrix), linear
+    end
+
+    return T, matrix, linear
+end
+
 end # module CUDAExt

ext/JuMPExt/JuMPExt.jl

@@ -33,6 +33,7 @@ const SQT{T}  = MOI.ScalarQuadraticTerm{T}
 const SQF{T}  = MOI.ScalarQuadraticFunction{T}
 
 const Engine = AOC.Solver.Engine
+const aoc_api = AOC.api
 
 include("variables.jl")
 include("wrapper.jl")

ext/JuMPExt/wrapper.jl

@@ -410,17 +410,26 @@ function MOI.optimize!(optimizer::Optimizer{T}) where {T<:Real}
         error("Unknown sense $(optimizer.sense)")
     end
 
-    @error "Solve here"
+    result = aoc_api.compute_qumo(
+        sense,
+        quadratic,
+        linear,
+        optimizer.continuous,
+        seed,
+        time_limit;
+        work_dir = work_dir,
+        engine   = backend,
+    )
 
     if !(T === num_type)
         output = Dict(
-            "Objective"  => convert(T, output["Objective"]),
-            "Assignment" => convert.(T, output["Assignment"]),
+            "Objective"  => convert(T, result.Objective),
+            "Assignment" => convert.(T, result.Assignment),
         )
     else
         output = Dict(
-            "Objective"  => output["Objective"],
-            "Assignment" => output["Assignment"],
+            "Objective"  => result.Objective,
+            "Assignment" => result.Assignment,
         )
     end
 

notebooks/test-jump.jl

@@ -17,3 +17,9 @@ model = Model(AOCoptimizer.MOI.Optimizer[])
 # The following will solve with default settings,
 # using 60sec as timeout value.
 optimize!(model)
+
+@show termination_status(model)
+@show objective_value(model)
+@show value(x)
+@show value(y)
+@show value(z)

src/AOCoptimizer.jl

@@ -47,6 +47,7 @@ include("FileFormats/FileFormats.jl")
 include("Algorithms/Algorithms.jl")
 
 include("Solver/Solver.jl")
+include("api/api.jl")
 
 include("precompile.jl")
 

src/Solver/core.jl

@@ -562,10 +562,19 @@ The `dt` parameter specifies the time step for the simulation.
 """
 function solve_qumo end
 
+const __solvers_registered::Ref{Bool} = Ref(false)
+
 function __register_solvers()
     @info "Registering default solvers"
 
+    if __solvers_registered[]
+        @warn "Solvers already registered, skipping"
+        return
+    end
+
     @eval @make_solver(solve_mixed_ising, explore_mixed_ising)
     @eval @make_solver(solve_positive_qumo, explore_positive_qumo)
     @eval @make_solver(solve_qumo, explore_qumo)
+
+    __solvers_registered[] = true
 end

src/Solver/normalization.jl

@@ -51,7 +51,7 @@ function _calculate_normalization_factor(interactions::AbstractMatrix{T}) where
         λ = ( abs(λ_max) + abs(λ_min) ) / T(2.0)
     end
 
-    @assert λ > 0.0 "Largest eigenvalue $λ is not positive"
+    @assert λ >= 0.0 "Largest eigenvalue $λ is not positive"
     if λ <= 0.1
         @warn "Normalization factor $λ is either negative or small; using 1.0 instead"
         λ = T(1.0)