[Utilities] add supports_shift_constant

[odow]

In order to close jump-dev/JuMP.jl#1943, we need a way of checking whether it is possible to push the function constant into the set. The easiest way is just to define this fallback, so the JuMP code will become:

function build_constraint(
    ::Function,
    expr::Union{GenericAffExpr, GenericQuadExpr},
    set::MOI.AbstractScalarSet,
)
    offset = constant(expr)
    new_set = MOIU.shift_constant(set, -offset)
    if new_set === nothing
        return ScalarConstraint(expr, set)
    else
        add_to_expression!(expr, -offset)
        return ScalarConstraint(expr, new_set)
    end
end

This makes JuMP's heuristic of "I'll push the constant into the set" well-defined by "does it implement shift_constant".

As a follow-up question: should this be moved to MOI proper?

[blegat]

I'm hesitant between this has adding a supports_constant_shift(::Type{<:MOI.AbstractScalarSet}) = false. The advantage of this PR is that it's not possible to implement shift_constant but forget to implement supports_constant_shift. The advantage of supports_constant_shift is that it can be checked when we only have the type of the set. A disadvantage of this PR is that if the user pass a constant of incorrect type, it might use the fallback even if there is a shift implemented.

[odow]

it's not possible to implement shift_constant but forget to implement supports_constant_shift.

I always get confused with out supports_xxx.

A disadvantage of this PR is that if the user pass a constant of incorrect type, it might use the fallback even if there is a shift implemented.

If they pass the incorrect type, then the shift implemented will not work anyway.

For example: shift_constant(MOI.EqualTo{Int}(1), 0.5). We shouldn't just check that MOI.EqualTo{Int} supports the shift.

[blegat]

If they pass the incorrect type, then the shift implemented will not work anyway.

Yes but shift_constant(MOI.EqualTo(1), 2.5) should probably error or return MOI.EqualTo(3.5), not nothing

[odow]

Returning nothing says that it isn't okay to shift the constant into the set. Otherwise we need to define supports_shift_constant(::Type{Set}, ::Type{T}).

And EqualTo could define to implement shift_contant(set::MOI.EqualTo, shift::T) = MOI.EqualTo(set.value + shift) if it so chose.

It really, do you want to implement an extra supports_shift_constant method, or do you want a nothing fallback?

[blegat]

Some user might also not see the error when nothing is returned, for instance if they store the result in a Any[]. Also, we might need to check whether the set can be shifted only with the set type (e.g. in concrete_bridge_type of a bridge).

[odow]

Some user might also not see the error when nothing is returned, for instance if they store the result in a Any[]

This is user-error.

Also, we might need to check whether the set can be shifted only with the set type

We haven't needed to yet?

[blegat]

This is user-error.

Why do you mean ? The user should never have Any[] vectors ?

We haven't needed to yet?

No, just speculative

[odow]

Why do you mean?

If the user doesn't check for a return of nothing, they're using the function wrong. Or you mean this is breaking because currently it will error?