Move code to MOI and add JuMP layer

Project.toml

@@ -4,12 +4,17 @@ version = "0.1.0"
 
 [deps]
 Dualization = "191a621a-6537-11e9-281d-650236a99e60"
-JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 
+[weakdeps]
+JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+
+[extensions]
+ModelAnalyzerJuMPExt = "JuMP"
+
 [compat]
-Dualization = "0.5.9"
+Dualization = "0.6.0"
 JuMP = "1.24.0"
 MathOptInterface = "1.37.0"

docs/Project.toml

@@ -1,3 +1,7 @@
 [deps]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
-ModelAnalyzer = "d1179b25-476b-425c-b826-c7787f0fff83"
+ModelAnalyzer = "d1179b25-476b-425c-b826-c7787f0fff83"
+JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+
+[compat]
+JuMP = "1.24.0"

docs/make.jl

@@ -1,4 +1,4 @@
-using Documenter, ModelAnalyzer
+using Documenter, ModelAnalyzer, JuMP
 
 makedocs(; sitename = "ModelAnalyzer.jl documentation")
 

docs/src/feasibility.md

@@ -17,7 +17,8 @@ Specifically, the possible issues are:
 
 ```@docs
 ModelAnalyzer.Feasibility.PrimalViolation
-ModelAnalyzer.Feasibility.DualViolation
+ModelAnalyzer.Feasibility.DualConstraintViolation
+ModelAnalyzer.Feasibility.DualConstrainedVariableViolation
 ModelAnalyzer.Feasibility.ComplemetarityViolation
 ModelAnalyzer.Feasibility.DualObjectiveMismatch
 ModelAnalyzer.Feasibility.PrimalObjectiveMismatch

ext/ModelAnalyzerJuMPExt/ModelAnalyzerJuMPExt.jl

@@ -0,0 +1,82 @@
+# Copyright (c) 2025: Joaquim Garcia, Oscar Dowson and contributors
+#
+# Use of this source code is governed by an MIT-style license that can be found
+# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
+
+module ModelAnalyzerJuMPExt
+
+import ModelAnalyzer
+import JuMP
+import MathOptInterface as MOI
+
+function ModelAnalyzer.analyze(
+    analyzer::T,
+    model::JuMP.GenericModel;
+    kwargs...,
+) where {T<:ModelAnalyzer.AbstractAnalyzer}
+    moi_model = JuMP.backend(model)
+    result = ModelAnalyzer.analyze(analyzer, moi_model; kwargs...)
+    return result
+end
+
+function ModelAnalyzer._name(
+    ref::MOI.VariableIndex,
+    model::JuMP.GenericModel{T},
+) where {T}
+    jump_ref = JuMP.GenericVariableRef{T}(model, ref)
+    name = JuMP.name(jump_ref)
+    if !isempty(name)
+        return name
+    end
+    return "$jump_ref"
+end
+
+function ModelAnalyzer._name(ref::MOI.ConstraintIndex, model::JuMP.GenericModel)
+    jump_ref = JuMP.constraint_ref_with_index(model, ref)
+    name = JuMP.name(jump_ref)
+    if !isempty(name)
+        return name
+    end
+    return "$jump_ref"
+end
+
+"""
+    variable(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
+
+Return the **JuMP** variable reference associated to a particular issue.
+"""
+function ModelAnalyzer.variable(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.GenericModel{T},
+) where {T}
+    ref = ModelAnalyzer.variable(issue)
+    return JuMP.GenericVariableRef{T}(model, ref)
+end
+
+"""
+    variables(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
+
+Return the **JuMP** variable references associated to a particular issue.
+"""
+function ModelAnalyzer.variables(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.GenericModel{T},
+) where {T}
+    refs = ModelAnalyzer.variables(issue)
+    return JuMP.GenericVariableRef{T}.(model, refs)
+end
+
+"""
+    constraint(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
+
+Return the **JuMP** constraint reference associated to a particular issue.
+"""
+function ModelAnalyzer.constraint(
+    issue::ModelAnalyzer.AbstractIssue,
+    model::JuMP.GenericModel,
+)
+    ref = ModelAnalyzer.constraint(issue)
+    return JuMP.constraint_ref_with_index(model, ref)
+end
+
+end # module ModelAnalyzerJuMPExt

src/ModelAnalyzer.jl

@@ -5,14 +5,16 @@
 
 module ModelAnalyzer
 
+import MathOptInterface as MOI
+
 abstract type AbstractIssue end
 
 abstract type AbstractData end
 
 abstract type AbstractAnalyzer end
 
 """
-    analyze(analyzer::AbstractAnalyzer, model::JuMP.Model; kwargs...)
+    analyze(analyzer::AbstractAnalyzer, model::JuMP.GenericModel; kwargs...)
 
 Analyze a JuMP model using the specified analyzer.
 Depending on the analyzer, this keyword arguments might vary.
@@ -25,10 +27,12 @@
 function analyze end
 
 """
-    summarize([io::IO,] AbstractData; verbose = true, max_issues = 10, kwargs...)
+    summarize([io::IO,] AbstractData; model = nothing, verbose = true, max_issues = 10, kwargs...)
 
 Print a summary of the analysis results contained in `AbstractData` to the
 specified IO stream. If no IO stream is provided, it defaults to `stdout`.
+The model that led to the issue can be provided to `model`, it will be
+used to generate the name of variables and constraints in the issue summary.
 The `verbose` flag controls whether to print detailed information about each
 issue (if `true`) or a concise summary (if `false`). The `max_issues` argument
 controls the maximum number of issues to display in the summary. If there are
@@ -41,9 +45,11 @@
 explaning the issue. In the non-verbose case it will provide just the issue
 name.
 
-    summarize([io::IO,] issue::AbstractIssue; verbose = true)
+    summarize([io::IO,] issue::AbstractIssue; model = nothing, verbose = true)
 
 This variant allows summarizing a single issue instance of type `AbstractIssue`.
+The model that led to the issue can be provided to `model`, it will be
+used to generate the name of variables and constraints in the issue summary.
 """
 function summarize end
 
@@ -76,11 +82,16 @@
     return summarize(stdout, T; kwargs...)
 end
 
-function summarize(io::IO, issue::AbstractIssue; verbose = true)
+function summarize(
+    io::IO,
+    issue::AbstractIssue;
+    model = nothing,
+    verbose = true,
+)
     if verbose
-        return _verbose_summarize(io, issue)
+        return _verbose_summarize(io, issue, model)
     else
-        return _summarize(io, issue)
+        return _summarize(io, issue, model)
     end
 end
 
@@ -93,6 +104,7 @@
 function summarize(
     io::IO,
     issues::Vector{T};
+    model = nothing,
     verbose = true,
     max_issues = DEFAULT_MAX_ISSUES,
 ) where {T<:AbstractIssue}
@@ -110,7 +122,7 @@
     end
     for issue in first(issues, max_issues)
         print(io, " * ")
-        summarize(io, issue, verbose = verbose)
+        summarize(io, issue, verbose = verbose, model = model)
         print(io, "\n")
     end
     return
@@ -124,11 +136,86 @@
     return summarize(stdout, data; kwargs...)
 end
 
+"""
+    value(issue::AbstractIssue)
+
+Return the value associated to a particular issue. The value is a number
+with a different meaning depending on the type of issue. For example, for
+some numerical issues, it can be the coefficient value.
+"""
+function value(issue::AbstractIssue, ::Nothing)
+    return value(issue)
+end
+
+function value(issue::AbstractIssue, ::MOI.ModelLike)
+    return value(issue)
+end
+
+"""
+    variable(issue::AbstractIssue)
+
+Return the variable associated to a particular issue.
+"""
+function variable(issue::AbstractIssue, ::Nothing)
+    return variable(issue)
+end
+
+function variable(issue::AbstractIssue, ::MOI.ModelLike)
+    return variable(issue)
+end
+
+"""
+    variables(issue::AbstractIssue)
+
+Return the variables associated to a particular issue.
+"""
+function variables(issue::AbstractIssue, ::Nothing)
+    return variables(issue)
+end
+
+function variables(issue::AbstractIssue, ::MOI.ModelLike)
+    return variables(issue)
+end
+
+"""
+    constraint(issue::AbstractIssue)
+
+Return the constraint associated to a particular issue.
+"""
+function constraint(issue::AbstractIssue, ::Nothing)
+    return constraint(issue)
+end
+
+function constraint(issue::AbstractIssue, ::MOI.ModelLike)
+    return constraint(issue)
+end
+
 function _verbose_summarize end
+
 function _summarize end
 
+function _name(ref::MOI.VariableIndex, model::MOI.ModelLike)
+    name = MOI.get(model, MOI.VariableName(), ref)
+    if !isempty(name)
+        return name
+    end
+    return "$ref"
+end
+
+function _name(ref::MOI.ConstraintIndex, model::MOI.ModelLike)
+    name = MOI.get(model, MOI.ConstraintName(), ref)
+    if !isempty(name)
+        return name
+    end
+    return "$ref"
+end
+
+function _name(ref, ::Nothing)
+    return "$ref"
+end
+
 include("numerical.jl")
 include("feasibility.jl")
 include("infeasibility.jl")
 
-end
+end # module ModelAnalyzer

src/_eval_variables.jl

@@ -0,0 +1,31 @@
+# Copyright (c) 2025: Joaquim Garcia, Oscar Dowson and contributors
+#
+# Use of this source code is governed by an MIT-style license that can be found
+# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
+
+function _eval_variables end
+
+function _eval_variables(value_fn::Function, t::MOI.ScalarAffineTerm)
+    return t.coefficient * value_fn(t.variable)
+end
+
+function _eval_variables(value_fn::Function, t::MOI.ScalarQuadraticTerm)
+    out = t.coefficient * value_fn(t.variable_1) * value_fn(t.variable_2)
+    return t.variable_1 == t.variable_2 ? out / 2 : out
+end
+
+_eval_variables(value_fn::Function, f::MOI.VariableIndex) = value_fn(f)
+
+function _eval_variables(
+    value_fn::Function,
+    f::MOI.ScalarAffineFunction{T},
+) where {T}
+    # TODO: this conversion exists in JuMP, but not in MOI
+    S = Base.promote_op(value_fn, MOI.VariableIndex)
+    U = Base.promote_op(*, T, S)
+    out = convert(U, f.constant)
+    for t in f.terms
+        out += _eval_variables(value_fn, t)
+    end
+    return out
+end