_APL (#39)

Author: blegat

src/SemialgebraicSets.jl

@@ -8,7 +8,7 @@ const MA = MutableArithmetics
 using MultivariatePolynomials
 const MP = MultivariatePolynomials
 
-const APL = AbstractPolynomialLike
+const _APL = AbstractPolynomialLike
 
 import CommonSolve: solve
 

src/basic.jl

@@ -1,31 +1,31 @@
 export inequalities, basic_semialgebraic_set
 
-struct BasicSemialgebraicSet{T,PT<:APL{T},AT<:AbstractAlgebraicSet} <:
+struct BasicSemialgebraicSet{T,PT<:_APL{T},AT<:AbstractAlgebraicSet} <:
        AbstractBasicSemialgebraicSet
     V::AT
     p::Vector{PT}
 end
-function BasicSemialgebraicSet{T,PT}() where {T,PT<:APL{T}}
+function BasicSemialgebraicSet{T,PT}() where {T,PT<:_APL{T}}
     return BasicSemialgebraicSet(AlgebraicSet{T,PT}(), PT[])
 end
 function BasicSemialgebraicSet(
     V::AlgebraicSet{T,PT,A,S},
     p::Vector{PT},
-) where {T,PT<:APL{T},A,S<:AbstractAlgebraicSolver}
+) where {T,PT<:_APL{T},A,S<:AbstractAlgebraicSolver}
     return BasicSemialgebraicSet{T,PT,typeof(V)}(V, p)
 end
 function BasicSemialgebraicSet(
     V::AlgebraicSet{T,PT,A,SO,U},
     p::Vector{PS},
-) where {T,PT<:APL{T},S,PS<:APL{S},A,SO<:AbstractAlgebraicSolver,U}
+) where {T,PT<:_APL{T},S,PS<:_APL{S},A,SO<:AbstractAlgebraicSolver,U}
     ST = promote_type(T, S)
     PST = promote_type(PT, PS)
     return BasicSemialgebraicSet(
         convert(AlgebraicSet{ST,PST,A,SO,U}, V),
         Vector{PST}(p),
     )
 end
-#BasicSemialgebraicSet{T, PT<:APL{T}}(V::AlgebraicSet{T, PT}, p::Vector{PT}) = BasicSemialgebraicSet{T, PT}(V, p)
+#BasicSemialgebraicSet{T, PT<:_APL{T}}(V::AlgebraicSet{T, PT}, p::Vector{PT}) = BasicSemialgebraicSet{T, PT}(V, p)
 function basic_semialgebraic_set(V, p)
     return BasicSemialgebraicSet(V, p)
 end
@@ -50,7 +50,7 @@ end
 
 function MP.variables(
     S::BasicSemialgebraicSet{T,PT,FullSpace},
-) where {T,PT<:APL{T}}
+) where {T,PT<:_APL{T}}
     return MP.variables(S.p)
 end
 function MP.variables(S::BasicSemialgebraicSet)

src/groebner.jl

@@ -10,7 +10,7 @@ S(p, q) =  \\frac{m}{\\mathrm{\\mathsc{LT}}(p)} \\cdot p - \\frac{m}{\\mathrm{\\
 ```
 where ``m = \\mathrm{lcm}(\\mathrm{\\mathsc{LM}}(p), \\mathrm{\\mathsc{LM}}(q))``.
 """
-function spolynomial(p::APL, q::APL)
+function spolynomial(p::_APL, q::_APL)
     m = lcm(leading_monomial(p), leading_monomial(q))
     ltp = leading_term(p)
     # `MA.operate` ensures that the returned value can be mutated without
@@ -23,7 +23,7 @@ function spolynomial(p::APL, q::APL)
     return MA.operate!!(-, ad, bd)
 end
 
-function reduce_basis!(F::AbstractVector{<:APL}; kwargs...)
+function reduce_basis!(F::AbstractVector{<:_APL}; kwargs...)
     changed = true
     while changed
         changed = false
@@ -138,7 +138,7 @@ promote_for(::Type{T}, ::Type{Buchberger}) where {T} = promote_for_division(T)
 # Ideals, Varieties, and Algorithms
 # Cox, Little and O'Shea, Fourth edition
 function gröbner_basis!(
-    F::AbstractVector{<:APL},
+    F::AbstractVector{<:_APL},
     algo = default_gröbner_basis_algorithm(F),
 )
     algo.pre!(F)
@@ -170,7 +170,7 @@ function gröbner_basis!(
     map!(monic, F, F)
     return F
 end
-function gröbner_basis(F::Vector{<:APL}, args...)
+function gröbner_basis(F::Vector{<:_APL}, args...)
     T = Base.promote_op(rem, eltype(F), typeof(F))
     return gröbner_basis!(copyto!(similar(F, T), F), args...)
 end

src/ideal.jl

@@ -8,33 +8,36 @@ function ideal(p::FullSpace, _ = default_gröbner_basis_algorithm(p))
 end
 Base.rem(p::AbstractPolynomialLike, ::EmptyPolynomialIdeal) = p
 
-mutable struct PolynomialIdeal{T,PT<:APL{T},A<:AbstractGröbnerBasisAlgorithm} <:
-               AbstractPolynomialIdeal
+mutable struct PolynomialIdeal{
+    T,
+    PT<:_APL{T},
+    A<:AbstractGröbnerBasisAlgorithm,
+} <: AbstractPolynomialIdeal
     p::Vector{PT}
     gröbner_basis::Bool
     algo::A
 end
 function PolynomialIdeal{T,PT}(
     p::Vector{PT},
     algo::A,
-) where {T,PT<:APL{T},A<:AbstractGröbnerBasisAlgorithm}
+) where {T,PT<:_APL{T},A<:AbstractGröbnerBasisAlgorithm}
     return PolynomialIdeal{T,PT,A}(p, false, algo)
 end
-function PolynomialIdeal(p::Vector{PT}, algo) where {T,PT<:APL{T}}
+function PolynomialIdeal(p::Vector{PT}, algo) where {T,PT<:_APL{T}}
     S = promote_for(T, typeof(algo))
     return PolynomialIdeal{S,polynomial_type(PT, S)}(
         AbstractVector{polynomial_type(PT, S)}(p),
         algo,
     )
 end
-function PolynomialIdeal{T,PT}() where {T,PT<:APL{T}}
+function PolynomialIdeal{T,PT}() where {T,PT<:_APL{T}}
     return PolynomialIdeal(PT[], default_gröbner_basis_algorithm(PT))
 end
 
 function Base.convert(
     ::Type{PolynomialIdeal{T,PT,A}},
     I::PolynomialIdeal{T,PT,A},
-) where {T,PT<:APL{T},A<:AbstractGröbnerBasisAlgorithm}
+) where {T,PT<:_APL{T},A<:AbstractGröbnerBasisAlgorithm}
     return I
 end
 function Base.convert(

src/solve.jl

@@ -165,7 +165,7 @@ function default_multiplication_matrices_solver(::Type{T}) where {T}
 end
 function default_multiplication_matrices_solver(
     ::AbstractVector{PT},
-) where {T,PT<:APL{T}}
+) where {T,PT<:_APL{T}}
     return default_multiplication_matrices_solver(T)
 end
 

src/variety.jl

@@ -10,19 +10,19 @@ function default_gröbner_basis_algorithm(p, lib::DefaultAlgebraicSetLibrary)
 end
 
 function default_algebraic_set_library(
-    ::Vector{<:APL},
+    ::Vector{<:_APL},
     solver::AbstractAlgebraicSolver,
 )
     return DefaultAlgebraicSetLibrary(solver)
 end
-function default_algebraic_set_library(p::Vector{<:APL}, solveroralgo...)
+function default_algebraic_set_library(p::Vector{<:_APL}, solveroralgo...)
     return default_algebraic_set_library(
         p,
         default_algebraic_solver(p, solveroralgo...),
     )
 end
 
-mutable struct AlgebraicSet{T,PT<:APL{T},A,S<:AbstractAlgebraicSolver,U} <:
+mutable struct AlgebraicSet{T,PT<:_APL{T},A,S<:AbstractAlgebraicSolver,U} <:
                AbstractAlgebraicSet
     I::PolynomialIdeal{T,PT,A}
     projective::Bool
@@ -56,7 +56,7 @@ end
 function Base.convert(
     ::Type{AlgebraicSet{T,PT,A,S,U}},
     set::AlgebraicSet{T,PT,A,S,U},
-) where {T,PT<:APL{T},A,S<:AbstractAlgebraicSolver,U}
+) where {T,PT<:_APL{T},A,S<:AbstractAlgebraicSolver,U}
     return set
 end
 function Base.convert(

test/variety.jl

@@ -8,7 +8,7 @@ struct DummyAlgo <: SemialgebraicSets.AbstractGröbnerBasisAlgorithm end
 SemialgebraicSets.default_algebraic_solver(::Any, ::DummyAlgo) = DummySolver()
 SemialgebraicSets.promote_for(::Type, ::Type{DummyAlgo}) = Int
 function SemialgebraicSets.gröbner_basis!(
-    ::AbstractVector{<:MP.APL},
+    ::AbstractVector{<:MP.AbstractPolynomialLike},
     ::DummyAlgo,
 )
     return error("Dummy algo")