Better printing of functions

[blegat]

It would be nice if we would have sprint(show, f) print the same as JuMP.function_string with MIME"text/plain" and sprint(show, "text/latex", f) print the same as JuMP.function_string with MIME"text/plain". We could also have sprint(print, f) print the suggestion of @odow in #2108 (comment).
Note that we already have all the code needed to do that in MOI.Utilities._to_string. We can just pass it a dummy

struct NoVariableNameModel <: MOI.ModelLike end
MOI.get(::NoVariableNameModel, ::MOI.VariableName, ::MOI.VariableIndex) = ""

[odow]

This is actually pretty incredible:

struct _NoVariableNameModel <: MOI.ModelLike end

function MOI.get(
    ::_NoVariableNameModel,
    ::MOI.VariableName,
    x::MOI.VariableIndex
)
    return "MOI.VariableIndex($(x.value))"
end

function Base.show(io::IO, mime::MIME, f::MOI.AbstractFunction)
    print(io, _to_string(_PrintOptions(mime), _NoVariableNameModel(), f))
    return
end

Is enough for everything.

julia> x = MOI.VariableIndex(1)
MOI.VariableIndex(1)

julia> 1.5 * x + 2.0
2.0 + 1.5 MOI.VariableIndex(1)

julia> 1.5 * x * x + 2.0
2.0 + 1.5 MOI.VariableIndex(1)²

julia> y = MOI.VariableIndex(2)
MOI.VariableIndex(2)

julia> 1.5 * x * y + 2.0
2.0 + 1.5 MOI.VariableIndex(1)*MOI.VariableIndex(2)

julia> MOI.Utilities.vectorize([x, y])
┌                    ┐
│MOI.VariableIndex(1)│
│MOI.VariableIndex(2)│
└                    ┘

julia> MOI.Utilities.vectorize([x, 1//2 * y])
┌                                    ┐
│(0//1) + (1//1) MOI.VariableIndex(1)│
│(0//1) + (1//2) MOI.VariableIndex(2)│
└                                    ┘

julia> MOI.Utilities.vectorize([3.0 * x + y, 2.0 * y])
┌                                                         ┐
│0.0 + 3.0 MOI.VariableIndex(1) + 1.0 MOI.VariableIndex(2)│
│0.0 + 2.0 MOI.VariableIndex(2)                           │
└                                                         ┘

Bikeshed the names?

• _[1]
• x[1]
• VI[1]
• VI(1)
• MOI.VariableIndex(1)

This would also massively simplify the 0.5 factor issue:

julia> MOI.ScalarQuadraticFunction(
       [MOI.ScalarQuadraticTerm(2.0, x, y), MOI.ScalarQuadraticTerm(3.0, x, x)],
       MOI.ScalarAffineTerm{Float64}[],
       1.5,
       )
1.5 + 2.0 MOI.VariableIndex(1)*MOI.VariableIndex(2) + 1.5 MOI.VariableIndex(1)²

[chriscoey]

short names are nice for readability. I was initially attracted to _[1] (familiar from JuMP). But then I thought - if the user lets VI = MOI.VariableIndex (or import ... as ...) then maybe it allows them to copy-paste a result like 2.0 + 1.5 VI(1) and get the same object as 2.0 + 1.5 MOI.VariableIndex(1).

[odow]

I've gone back and forwards on this. I think the most confusing part is that JuMP prints String names by default, and only prints _ if there is no name (makes sense).

But MOI is going to always print the no-name version because names are stored in a model, not in the variable index. So something like _[1] won't make sense if the user has set MOI.set(model, MOI.VariableName(), x, "x").

I also thought about x[1] or VI(1), but they all seem to magical, and it gives the weird case that Julia> MOI.VariableIndex(1) would print as VI(1), which can't be copy-pasted.

So I went with MOI.VariableIndex, even though it's a bit longer. It's still a win compared with what we had before, and no one should be using the printing for anything with lots of variables.

[chriscoey]

my thinking was that you can't copy paste a VectorAffineFunction (with the big bracket syntax) anyway.

i guess i see your point about "magical" because the user might not know what VI means. and if we use VI then to be consistent we might want to use acronyms in other places too e.g. SAF/VAF

[odow]

because the user might not know what VI means. and if we use VI then to be consistent we might want to use acronyms in other places too e.g. SAF/VAF

After reading through a bunch of code written in MOI, all the solvers, some extension packages, working in MOI for the last couple of years, my conclusion was that the inconsistent use of acronyms destroys readability. I've worked/am working to make MOI be the only acronym we use. All the MOIU and CI and VI are super cryptic for people just entering the code base.

[chriscoey]

Yep that's fair

[blegat]

MOI.VariableIndex is nice but it won't work well in LaTeX mode. v[i] and v_i will be short and readable so I would for for that. It's not copy-pastable anyway if we go for MOI.VariableIndex(1)²
By the way it's actually already the default:

MathOptInterface.jl/src/Utilities/print.jl

Line 36 in ea66fd8

default_name::String = "v",

so

julia> import MathOptInterface as MOI

julia> function Base.show(io::IO, mime::MIME"text/latex", f::MOI.AbstractFunction)
           print(io, MOI.Utilities._to_string(MOI.Utilities._PrintOptions(mime), NoVariableNameModel(), f))
           return
       end

julia> struct NoVariableNameModel <: MOI.ModelLike end

julia> MOI.get(::NoVariableNameModel, ::MOI.VariableName, ::MOI.VariableIndex) = ""

julia> x = MOI.VariableIndex(1);

julia> function Base.show(io::IO, f::MOI.AbstractFunction)
           print(io, MOI.Utilities._to_string(MOI.Utilities._PrintOptions(MIME"text/plain"()), NoVariableNameModel(), f))
           return
       end

julia> show(2x + 1)
(1) + (2) v[1]
julia> show(stdout, MIME"text/latex"(), 2x + 1)
(1) + (2) v_{1}

[odow]

I guess that v[1] only shows up if you print the model, whereas this is going to show up everywhere.

We could make it print v_$I in MIME"text/latex" and MOI.VariableIndex in MIME"text/plain". They don't have to be the same.

[blegat]

Yes, that's a good idea