Add primal_feasibility_report(::Function

docs/src/manual/solutions.md

@@ -451,7 +451,7 @@ MOI.get(model, MOI.ConstraintConflictStatus(), c2)
 new_model, reference_map = copy_conflict(model)
 ```
 
-Conflicting constraints can be collected in a list and printed 
+Conflicting constraints can be collected in a list and printed
 as follows:
 
 ```julia
@@ -564,3 +564,12 @@ julia> primal_feasibility_report(model, Dict(x => 2.1); skip_missing = true)
 Dict{Any, Float64} with 1 entry:
   x integer => 0.1
 ```
+
+You can also use the functional form, where the first argument is a function
+that maps variables to their primal values:
+```jldoctest feasibility
+julia> optimize!(model)
+
+julia> primal_feasibility_report(v -> value(v), model)
+Dict{Any, Float64}()
+```

src/feasibility_checker.jl

@@ -57,7 +57,11 @@ function primal_feasibility_report(
     atol::Float64 = 0.0,
     skip_missing::Bool = false,
 )
-    function point_f(x::VariableRef)
+    return primal_feasibility_report(
+        model;
+        atol = atol,
+        skip_missing = skip_missing,
+    ) do x
         fx = get(point, x, missing)
         if ismissing(fx) && !skip_missing
             error(
@@ -67,14 +71,47 @@ function primal_feasibility_report(
         end
         return fx
     end
+end
+
+"""
+    primal_feasibility_report(
+        point::Function,
+        model::Model;
+        atol::Float64 = 0.0,
+        skip_missing::Bool = false,
+    )
+
+A form of `primal_feasibility_report` where a function is passed as the first
+argument instead of a dictionary as the second argument.
+
+## Examples
+
+```jldoctest; setup=:(using JuMP)
+julia> model = Model();
+
+julia> @variable(model, 0.5 <= x <= 1);
+
+julia> primal_feasibility_report(model) do v
+           return value(v)
+       end
+Dict{Any,Float64} with 1 entry:
+    x ≥ 0.5 => 0.3
+```
+"""
+function primal_feasibility_report(
+    point::Function,
+    model::Model;
+    atol::Float64 = 0.0,
+    skip_missing::Bool = false,
+)
     violated_constraints = Dict{Any,Float64}()
     for (F, S) in list_of_constraint_types(model)
         _add_infeasible_constraints(
             model,
             F,
             S,
             violated_constraints,
-            point_f,
+            point,
             atol,
         )
     end
@@ -88,7 +125,7 @@ function primal_feasibility_report(
         _add_infeasible_nonlinear_constraints(
             model,
             violated_constraints,
-            point_f,
+            point,
             atol,
         )
     end

test/feasibility_checker.jl

@@ -117,6 +117,21 @@ function test_primal_solution()
     @test isempty(report)
 end
 
+function test_primal_solution_func()
+    model = Model(() -> MOIU.MockOptimizer(MOIU.Model{Float64}()))
+    @variable(model, x, Bin)
+    optimize!(model)
+    mock = unsafe_backend(model)
+    MOI.set(mock, MOI.TerminationStatus(), MOI.OPTIMAL)
+    MOI.set(mock, MOI.PrimalStatus(), MOI.FEASIBLE_POINT)
+    MOI.set(mock, MOI.VariablePrimal(), optimizer_index(x), 1.0)
+    report = primal_feasibility_report(model) do xi
+        return value(xi)
+    end
+    @test isempty(report)
+    return
+end
+
 function test_feasible()
     model = Model()
     @variable(model, x, Bin)
@@ -181,6 +196,24 @@ function test_scalar_affine()
     @test length(report) == 4
 end
 
+function test_scalar_affine_func()
+    model = Model()
+    @variable(model, x)
+    @constraint(model, c1, x <= 0.5)
+    @constraint(model, c2, x >= 1.25)
+    @constraint(model, c3, x == 1.1)
+    @constraint(model, c4, 0 <= x <= 0.5)
+    report = primal_feasibility_report(model) do _
+        return 1.0
+    end
+    @test report[c1] ≈ 0.5
+    @test report[c2] ≈ 0.25
+    @test report[c3] ≈ 0.1
+    @test report[c4] ≈ 0.5
+    @test length(report) == 4
+    return
+end
+
 function test_scalar_quadratic()
     model = Model()
     @variable(model, x)