Remplace const by import as (#89)

* Remplace const by import as

* Fixes

* Fix

* Fix format

Author: blegat

src/Bridges/Constraint/Constraint.jl

@@ -1,15 +1,10 @@
 module Constraint
 
-using MultivariatePolynomials
-const MP = MultivariatePolynomials
-import MultivariateBases
-const MB = MultivariateBases
-import SemialgebraicSets
-const SS = SemialgebraicSets
-import MultivariateMoments
-const MM = MultivariateMoments
-import MathOptInterface
-const MOI = MathOptInterface
+import MultivariatePolynomials as MP
+import MultivariateBases as MB
+import SemialgebraicSets as SS
+import MultivariateMoments as MM
+import MathOptInterface as MOI
 
 using PolyJuMP
 

src/Bridges/Constraint/to_polynomial.jl

@@ -2,7 +2,7 @@ import DynamicPolynomials
 
 const VariableOrder =
     DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}
-const MonomialOrder = Graded{LexOrder}
+const MonomialOrder = MP.Graded{MP.LexOrder}
 const VarType = DynamicPolynomials.Variable{VariableOrder,MonomialOrder}
 const PolyType{T} = DynamicPolynomials.Polynomial{VariableOrder,MonomialOrder,T}
 const FuncType{T} = PolyJuMP.ScalarPolynomialFunction{T,PolyType{T}}

src/Bridges/Constraint/zero_polynomial.jl

@@ -1,7 +1,7 @@
 struct ZeroPolynomialBridge{
     T,
     F<:MOI.AbstractVectorFunction,
-    MT<:AbstractMonomial,
+    MT<:MP.AbstractMonomial,
     MVT<:AbstractVector{MT},
 } <: MOI.Bridges.Constraint.AbstractBridge
     zero_constraint::MOI.ConstraintIndex{F,MOI.Zeros}

src/Bridges/Constraint/zero_polynomial_in_algebraic_set.jl

@@ -22,7 +22,7 @@ function MOI.Bridges.Constraint.bridge_constraint(
     f::MOI.AbstractVectorFunction,
     s::PolyJuMP.ZeroPolynomialSet{<:SS.AbstractAlgebraicSet},
 ) where {T,F,BT,DT,MT,MVT}
-    p = polynomial(MOI.Utilities.scalarize(f), s.monomials)
+    p = MP.polynomial(MOI.Utilities.scalarize(f), s.monomials)
     # As `*(::MOI.ScalarAffineFunction{T}, ::S)` is only defined if `S == T`, we
     # need to call `similar`. This is critical since `T` is
     # `Float64` when used with JuMP and the coefficient type is often `Int` with

src/KKT/KKT.jl

@@ -1,13 +1,10 @@
 module KKT
 
-import MutableArithmetics
-const MA = MutableArithmetics
+import MutableArithmetics as MA
 
-import MathOptInterface
-const MOI = MathOptInterface
+import MathOptInterface as MOI
 
-import MultivariatePolynomials
-const MP = MultivariatePolynomials
+import MultivariatePolynomials as MP
 
 import SemialgebraicSets
 

src/PolyJuMP.jl

@@ -1,16 +1,13 @@
 module PolyJuMP
 
-import MutableArithmetics
-const MA = MutableArithmetics
+import MutableArithmetics as MA
 
 # MultivariatePolynomials extension
 
-using MultivariatePolynomials
-const MP = MultivariatePolynomials
-import MultivariateBases
-const MB = MultivariateBases
-using MultivariateMoments
-using SemialgebraicSets
+import MultivariatePolynomials as MP
+import MultivariateBases as MB
+import MultivariateMoments as MM
+import SemialgebraicSets as SS
 
 # MOI extension
 

src/attributes.jl

@@ -48,14 +48,12 @@ end
 
 # This is type piracy but we tolerate it.
 const ObjectWithoutIndex = Union{
-    AbstractMonomial,
-    AbstractTerm{<:MOI.Utilities.ObjectWithoutIndex},
-    AbstractPolynomial{<:MOI.Utilities.ObjectWithoutIndex},
+    MP.AbstractMonomial,
+    MP.AbstractTerm{<:MOI.Utilities.ObjectWithoutIndex},
+    MP.AbstractPolynomial{<:MOI.Utilities.ObjectWithoutIndex},
     MB.AbstractPolynomialBasis,
-    MultivariateMoments.AbstractMomentMatrix{
-        <:MOI.Utilities.ObjectWithoutIndex,
-    },
-    MultivariateMoments.AbstractMeasure{<:MOI.Utilities.ObjectWithoutIndex},
+    MM.AbstractMomentMatrix{<:MOI.Utilities.ObjectWithoutIndex},
+    MM.AbstractMeasure{<:MOI.Utilities.ObjectWithoutIndex},
 }
 const ObjectOrTupleWithoutIndex =
     Union{ObjectWithoutIndex,Tuple{Vararg{ObjectWithoutIndex}}}

src/constraint.jl

@@ -18,34 +18,34 @@ function JuMP.function_string(::MIME"text/plain", p::MP.AbstractPolynomialLike)
 end
 function JuMP.function_string(::MIME"text/latex", p::MP.AbstractPolynomialLike)
     # `show` prints `$$` around what `_show` prints.
-    return sprint(MultivariatePolynomials._show, MIME"text/latex"(), p)
+    return sprint(MP._show, MIME"text/latex"(), p)
 end
 
 ### Shapes for polynomial/moments primal-dual pair ###
 
 # Inspired from `JuMP.dual_shape` docstring example
-struct PolynomialShape{MT<:AbstractMonomial,MVT<:AbstractVector{MT}} <:
+struct PolynomialShape{MT<:MP.AbstractMonomial,MVT<:AbstractVector{MT}} <:
        JuMP.AbstractShape
     monomials::MVT
 end
 function JuMP.reshape_vector(x::Vector, shape::PolynomialShape)
-    return polynomial(x, shape.monomials)
+    return MP.polynomial(x, shape.monomials)
 end
-struct MomentsShape{MT<:AbstractMonomial,MVT<:AbstractVector{MT}} <:
+struct MomentsShape{MT<:MP.AbstractMonomial,MVT<:AbstractVector{MT}} <:
        JuMP.AbstractShape
     monomials::MVT
 end
 function JuMP.reshape_vector(x::Vector, shape::MomentsShape)
-    return measure(x, shape.monomials)
+    return MM.measure(x, shape.monomials)
 end
 JuMP.dual_shape(shape::PolynomialShape) = MomentsShape(shape.monomials)
 JuMP.dual_shape(shape::MomentsShape) = PolynomialShape(shape.monomials)
 
 JuMP.reshape_set(::ZeroPolynomialSet, ::PolynomialShape) = ZeroPoly()
 function JuMP.moi_set(
     ::ZeroPoly,
-    monos::AbstractVector{<:AbstractMonomial};
-    domain::AbstractSemialgebraicSet = FullSpace(),
+    monos::AbstractVector{<:MP.AbstractMonomial};
+    domain::SS.AbstractSemialgebraicSet = SS.FullSpace(),
     basis = MB.MonomialBasis,
 )
     return ZeroPolynomialSet(domain, basis, monos)
@@ -56,7 +56,7 @@ end
 
 Return the [`MomentsAttribute`](@ref) of `cref`.
 """
-function MultivariateMoments.moments(cref::JuMP.ConstraintRef)
+function MM.moments(cref::JuMP.ConstraintRef)
     return MOI.get(cref.model, MomentsAttribute(), cref)
 end
 
@@ -79,14 +79,14 @@ bridges(S::Type{<:MOI.AbstractSet}) = bridges(MOI.VectorOfVariables, S)
 
 function bridges(
     F::Type{<:MOI.AbstractVectorFunction},
-    ::Type{<:ZeroPolynomialSet{FullSpace}},
+    ::Type{<:ZeroPolynomialSet{SS.FullSpace}},
 )
     return [(Bridges.Constraint.ZeroPolynomialBridge, _coef_type(F))]
 end
 
 function bridges(
     F::Type{<:MOI.AbstractVectorFunction},
-    ::Type{<:ZeroPolynomialSet{<:AbstractAlgebraicSet}},
+    ::Type{<:ZeroPolynomialSet{<:SS.AbstractAlgebraicSet}},
 )
     return [(
         Bridges.Constraint.ZeroPolynomialInAlgebraicSetBridge,
@@ -183,19 +183,19 @@ function non_constant(a::AbstractVector{T}) where {T}
     # also take care of `collect`ing into a `Vector`
     return convert(Vector{non_constant_type(T)}, a)
 end
-non_constant_coefficients(p) = non_constant(coefficients(p))
+non_constant_coefficients(p) = non_constant(MP.coefficients(p))
 
 ## ZeroPoly
 function JuMP.build_constraint(
     _error::Function,
-    p::AbstractPolynomialLike,
+    p::MP.AbstractPolynomialLike,
     s::ZeroPoly;
-    domain::AbstractSemialgebraicSet = FullSpace(),
+    domain::SS.AbstractSemialgebraicSet = SS.FullSpace(),
     kws...,
 )
     coefs = non_constant_coefficients(p)
-    monos = monomials(p)
-    if domain isa BasicSemialgebraicSet
+    monos = MP.monomials(p)
+    if domain isa SS.BasicSemialgebraicSet
         # p(x) = 0 for all x in a basic semialgebraic set. We replace it by
         # p(x) ≤ 0 and p(x) ≥ 0 for all x in the basic semialgebraic set.
         # We need to determine the cone two use for `NonNegPoly` which is stored
@@ -222,7 +222,7 @@ function JuMP.build_constraint(
 end
 function JuMP.build_constraint(
     _error::Function,
-    p::AbstractPolynomialLike,
+    p::MP.AbstractPolynomialLike,
     s::MOI.EqualTo;
     kws...,
 )
@@ -258,7 +258,7 @@ function JuMP.add_constraint(
 )
     cone = getdefault(model, NonNegPoly())
     coefs = non_constant_coefficients(constraint.polynomial_or_matrix)
-    monos = monomials(constraint.polynomial_or_matrix)
+    monos = MP.monomials(constraint.polynomial_or_matrix)
     set = PlusMinusSet(JuMP.moi_set(cone, monos; constraint.kws...))
     new_constraint = JuMP.VectorConstraint(coefs, set, PolynomialShape(monos))
     bridgeable_con = bridgeable(
@@ -287,15 +287,15 @@ end
 # `NonNegPoly`
 function JuMP.build_constraint(
     _error::Function,
-    p::AbstractPolynomialLike,
+    p::MP.AbstractPolynomialLike,
     s::MOI.GreaterThan;
     kws...,
 )
     return JuMP.build_constraint(_error, p - s.lower, NonNegPoly(); kws...)
 end
 function JuMP.build_constraint(
     _error::Function,
-    p::AbstractPolynomialLike,
+    p::MP.AbstractPolynomialLike,
     s::MOI.LessThan;
     kws...,
 )
@@ -307,7 +307,7 @@ end
 # need a more specific here to avoid ambiguity
 function JuMP.build_constraint(
     _error::Function,
-    p::AbstractMatrix{<:AbstractPolynomialLike},
+    p::AbstractMatrix{<:MP.AbstractPolynomialLike},
     s::PSDCone;
     kws...,
 )
@@ -317,7 +317,7 @@ end
 # Needed for the syntax `@constraint(model, A >= B, PSDCone())`
 function JuMP.build_constraint(
     _error::Function,
-    f::AbstractMatrix{<:AbstractPolynomialLike},
+    f::AbstractMatrix{<:MP.AbstractPolynomialLike},
     s::MOI.GreaterThan,
     extra::PSDCone,
 )
@@ -328,7 +328,7 @@ end
 # Needed for the syntax `@constraint(model, A <= B, PSDCone())`
 function JuMP.build_constraint(
     _error::Function,
-    f::AbstractMatrix{<:AbstractPolynomialLike},
+    f::AbstractMatrix{<:MP.AbstractPolynomialLike},
     s::MOI.LessThan,
     extra::PSDCone,
 )

src/functions.jl

@@ -7,7 +7,7 @@
 Defines the polynomial function of the variables `variables` where the variable
 `variables(p)[i]` corresponds to `variables[i]`.
 """
-struct ScalarPolynomialFunction{T,P<:AbstractPolynomial{T}} <:
+struct ScalarPolynomialFunction{T,P<:MP.AbstractPolynomial{T}} <:
        MOI.AbstractScalarFunction
     polynomial::P
     variables::Vector{MOI.VariableIndex}
@@ -29,7 +29,7 @@ function Base.convert(
     vi::MOI.VariableIndex,
 ) where {T,P}
     x = _polynomial_variable(P, vi)
-    return ScalarPolynomialFunction{T,P}(polynomial(x, T), [vi])
+    return ScalarPolynomialFunction{T,P}(MP.polynomial(x, T), [vi])
 end
 
 function _polynomial_variables!(::Type{P}, variables) where {P}
@@ -59,7 +59,7 @@ function Base.convert(
     func::MOI.ScalarAffineFunction{T},
 ) where {T,P}
     variables = [t.variable for t in func.terms]
-    x, d = _polynomial_variables!(P, variables)
+    _, d = _polynomial_variables!(P, variables)
     poly = _polynomial_with_variables(P, func, d)
     return ScalarPolynomialFunction{T,P}(poly, variables)
 end
@@ -72,7 +72,7 @@ function Base.convert(
     quad_variables_1 = [t.variable_1 for t in func.quadratic_terms]
     quad_variables_2 = [t.variable_2 for t in func.quadratic_terms]
     variables = [linear_variables; quad_variables_1; quad_variables_2]
-    x, d = _polynomial_variables!(P, variables)
+    _, d = _polynomial_variables!(P, variables)
     terms = MP.term_type(P)[MOI.constant(func)]
     for t in func.affine_terms
         push!(terms, MP.term(t.coefficient, d[t.variable]))
@@ -81,7 +81,7 @@ function Base.convert(
         coef = t.variable_1 == t.variable_2 ? t.coefficient / 2 : t.coefficient
         push!(terms, MP.term(coef, d[t.variable_1] * d[t.variable_2]))
     end
-    return ScalarPolynomialFunction{T,P}(polynomial(terms), variables)
+    return ScalarPolynomialFunction{T,P}(MP.polynomial(terms), variables)
 end
 
 function Base.convert(
@@ -111,7 +111,7 @@ function MOI.Utilities.substitute_variables(
     new_aff =
         MOI.ScalarAffineFunction{T}[variable_map(var) for var in func.variables]
     variables = collect(Iterators.flatten(_variables(aff) for aff in new_aff))
-    x, d = _polynomial_variables!(P, variables)
+    _, d = _polynomial_variables!(P, variables)
     new_polys = [_polynomial_with_variables(P, aff, d) for aff in new_aff]
     new_poly = func.polynomial(MP.variables(func.polynomial) => new_polys)
     return ScalarPolynomialFunction{T,typeof(new_poly)}(new_poly, variables)

src/nl_to_polynomial.jl

@@ -3,7 +3,7 @@
 import DynamicPolynomials
 const VariableOrder =
     DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}
-const MonomialOrder = Graded{LexOrder}
+const MonomialOrder = MP.Graded{MP.LexOrder}
 const VarType = DynamicPolynomials.Variable{VariableOrder,MonomialOrder}
 const PolyType{T} = DynamicPolynomials.Polynomial{VariableOrder,MonomialOrder,T}
 const FuncType{T} = ScalarPolynomialFunction{T,PolyType{T}}