Automatic exports (#262)

* Automatic exports

* Fix format

Author: blegat

src/MultivariatePolynomials.jl

@@ -6,8 +6,6 @@ import DataStructures
 
 import MutableArithmetics as MA
 
-export AbstractPolynomialLike, AbstractTermLike, AbstractMonomialLike
-
 """
     AbstractPolynomialLike{T}
 
@@ -31,7 +29,6 @@ Abstract type for a value that can act like a monomial. For instance, an `Abstra
 """
 abstract type AbstractMonomialLike <: AbstractTermLike{Int} end
 
-export AbstractVariable, AbstractMonomial, AbstractTerm, AbstractPolynomial
 """
     AbstractVariable <: AbstractMonomialLike
 
@@ -60,7 +57,7 @@ Abstract type for a polynomial of coefficient type `T`, i.e. a sum of `AbstractT
 """
 abstract type AbstractPolynomial{T} <: AbstractPolynomialLike{T} end
 
-const APL{T} = AbstractPolynomialLike{T}
+const _APL{T} = AbstractPolynomialLike{T}
 
 include("zip.jl")
 include("lazy_iterators.jl")
@@ -97,4 +94,22 @@ include("default_polynomial.jl")
 
 include("deprecate.jl")
 
+const _EXCLUDE_SYMBOLS = [Symbol(@__MODULE__), :eval, :include]
+
+for sym in names(@__MODULE__; all = true)
+    sym_string = string(sym)
+    if sym in _EXCLUDE_SYMBOLS ||
+       startswith(sym_string, "_") ||
+       startswith(sym_string, "@_")
+        continue
+    end
+    if !(
+        Base.isidentifier(sym) ||
+        (startswith(sym_string, "@") && Base.isidentifier(sym_string[2:end]))
+    )
+        continue
+    end
+    @eval export $sym
+end
+
 end # module

src/antidifferentiation.jl

@@ -1,5 +1,3 @@
-export antidifferentiate
-
 """
     antidifferentiate(p::AbstractPolynomialLike, v::AbstractVariable, deg::Union{Int, Val}=1)
 
@@ -34,16 +32,16 @@ end
 function antidifferentiate(t::AbstractTermLike, v::AbstractVariable)
     return coefficient(t) * antidifferentiate(monomial(t), v)
 end
-function antidifferentiate(p::APL, v::AbstractVariable)
+function antidifferentiate(p::_APL, v::AbstractVariable)
     return polynomial!(antidifferentiate.(terms(p), v), SortedState())
 end
 
 # TODO: this signature is probably too wide and creates the potential
 # for stack overflows
-antidifferentiate(p::APL, xs) = [antidifferentiate(p, x) for x in xs]
+antidifferentiate(p::_APL, xs) = [antidifferentiate(p, x) for x in xs]
 
 # antidifferentiate(p, [x, y]) with TypedPolynomials promote x to a Monomial
-function antidifferentiate(p::APL, m::AbstractMonomial)
+function antidifferentiate(p::_APL, m::AbstractMonomial)
     return antidifferentiate(p, variable(m))
 end
 

src/chain_rules.jl

@@ -1,15 +1,15 @@
 import ChainRulesCore
 
-ChainRulesCore.@scalar_rule +(x::APL) true
-ChainRulesCore.@scalar_rule -(x::APL) -1
+ChainRulesCore.@scalar_rule +(x::_APL) true
+ChainRulesCore.@scalar_rule -(x::_APL) -1
 
-ChainRulesCore.@scalar_rule +(x::APL, y::APL) (true, true)
-ChainRulesCore.@scalar_rule -(x::APL, y::APL) (true, -1)
+ChainRulesCore.@scalar_rule +(x::_APL, y::_APL) (true, true)
+ChainRulesCore.@scalar_rule -(x::_APL, y::_APL) (true, -1)
 
-function ChainRulesCore.frule((_, Δp, Δq), ::typeof(*), p::APL, q::APL)
+function ChainRulesCore.frule((_, Δp, Δq), ::typeof(*), p::_APL, q::_APL)
     return p * q, MA.add_mul!!(p * Δq, q, Δp)
 end
-function ChainRulesCore.rrule(::typeof(*), p::APL, q::APL)
+function ChainRulesCore.rrule(::typeof(*), p::_APL, q::_APL)
     function times_pullback2(ΔΩ̇)
         #ΔΩ = ChainRulesCore.unthunk(Ω̇)
         #return (ChainRulesCore.NoTangent(), ChainRulesCore.ProjectTo(p)(ΔΩ * q'), ChainRulesCore.ProjectTo(q)(p' * ΔΩ))

src/comparison.jl

@@ -1,7 +1,3 @@
-export isapproxzero
-
-export LexOrder, InverseLexOrder, Reverse, Graded
-
 Base.iszero(v::AbstractVariable) = false
 Base.iszero(m::AbstractMonomial) = false
 Base.iszero(t::AbstractTerm) = iszero(coefficient(t))
@@ -16,10 +12,10 @@ end
 
 # See https://github.com/blegat/MultivariatePolynomials.jl/issues/22
 # avoids the call to be transfered to left_constant_eq
-Base.:(==)(α::Nothing, x::APL) = false
-Base.:(==)(x::APL, α::Nothing) = false
-Base.:(==)(α::Dict, x::APL) = false
-Base.:(==)(x::APL, α::Dict) = false
+Base.:(==)(α::Nothing, x::_APL) = false
+Base.:(==)(x::_APL, α::Nothing) = false
+Base.:(==)(α::Dict, x::_APL) = false
+Base.:(==)(x::_APL, α::Dict) = false
 Base.:(==)(α::Nothing, x::RationalPoly) = false
 Base.:(==)(x::RationalPoly, α::Nothing) = false
 Base.:(==)(α::Dict, x::RationalPoly) = false
@@ -33,7 +29,7 @@ function right_term_eq(p::AbstractPolynomial, t)
         nterms(p) == 1 && leading_term(p) == t
     end
 end
-right_term_eq(p::APL, t) = right_term_eq(polynomial(p), t)
+right_term_eq(p::_APL, t) = right_term_eq(polynomial(p), t)
 
 left_constant_eq(α, v::AbstractVariable) = false
 right_constant_eq(v::AbstractVariable, α) = false
@@ -46,8 +42,8 @@ function _term_constant_eq(t::AbstractTermLike, α)
 end
 left_constant_eq(α, t::AbstractTermLike) = _term_constant_eq(t, α)
 right_constant_eq(t::AbstractTermLike, α) = _term_constant_eq(t, α)
-left_constant_eq(α, p::APL) = right_term_eq(p, α)
-right_constant_eq(p::APL, α) = right_term_eq(p, α)
+left_constant_eq(α, p::_APL) = right_term_eq(p, α)
+right_constant_eq(p::_APL, α) = right_term_eq(p, α)
 
 function Base.:(==)(mono::AbstractMonomial, v::AbstractVariable)
     return isone(degree(mono)) && variable(mono) == v
@@ -117,8 +113,8 @@ end
 
 Base.:(==)(p::RationalPoly, q::RationalPoly) = p.num * q.den == q.num * p.den
 # Solve ambiguity with (::PolyType, ::Any)
-Base.:(==)(p::APL, q::RationalPoly) = p * q.den == q.num
-Base.:(==)(q::RationalPoly, p::APL) = p == q
+Base.:(==)(p::_APL, q::RationalPoly) = p * q.den == q.num
+Base.:(==)(q::RationalPoly, p::_APL) = p == q
 Base.:(==)(α, q::RationalPoly) = α * q.den == q.num
 Base.:(==)(q::RationalPoly, α) = α == q
 
@@ -132,7 +128,7 @@ isapproxzero(m::AbstractMonomialLike; kwargs...) = false
 function isapproxzero(t::AbstractTermLike; kwargs...)
     return isapproxzero(coefficient(t); kwargs...)
 end
-function isapproxzero(p::APL; kwargs...)
+function isapproxzero(p::_APL; kwargs...)
     return all(term -> isapproxzero(term; kwargs...), terms(p))
 end
 isapproxzero(p::RationalPoly; kwargs...) = isapproxzero(p.num; kwargs...)
@@ -159,10 +155,10 @@ end
 function Base.isapprox(p::RationalPoly, q::RationalPoly; kwargs...)
     return isapprox(p.num * q.den, q.num * p.den; kwargs...)
 end
-function Base.isapprox(p::RationalPoly, q::APL; kwargs...)
+function Base.isapprox(p::RationalPoly, q::_APL; kwargs...)
     return isapprox(p.num, q * p.den; kwargs...)
 end
-function Base.isapprox(p::APL, q::RationalPoly; kwargs...)
+function Base.isapprox(p::_APL, q::RationalPoly; kwargs...)
     return isapprox(p * q.den, q.num; kwargs...)
 end
 function Base.isapprox(q::RationalPoly{C}, α; kwargs...) where {C}

src/conversion.jl

@@ -1,14 +1,12 @@
-export variable, convert_to_constant
-
 function convert_constant end
-Base.convert(::Type{P}, α) where {P<:APL} = convert_constant(P, α)
+Base.convert(::Type{P}, α) where {P<:_APL} = convert_constant(P, α)
 function convert_constant(::Type{TT}, α) where {T,TT<:AbstractTerm{T}}
     return term(convert(T, α), constant_monomial(TT))
 end
 function convert_constant(::Type{PT}, α) where {PT<:AbstractPolynomial}
     return convert(PT, convert(term_type(PT), α))
 end
-function Base.convert(::Type{P}, p::APL) where {T,P<:AbstractPolynomial{T}}
+function Base.convert(::Type{P}, p::_APL) where {T,P<:AbstractPolynomial{T}}
     return error("`convert` not implemented for $P")
 end
 
@@ -84,7 +82,7 @@ MA.scaling(p::AbstractPolynomialLike{T}) where {T} = convert(T, p)
 # Conversion polynomial -> constant
 # We don't define a method for `Base.convert` to reduce invalidations;
 # see https://github.com/JuliaAlgebra/MultivariatePolynomials.jl/pull/172
-function convert_to_constant(::Type{S}, p::APL) where {S}
+function convert_to_constant(::Type{S}, p::_APL) where {S}
     s = zero(S)
     for t in terms(p)
         if !isconstant(t)
@@ -95,10 +93,10 @@ function convert_to_constant(::Type{S}, p::APL) where {S}
     end
     return s
 end
-Base.convert(::Type{T}, p::APL) where {T<:Number} = convert_to_constant(T, p)
-function convert_to_constant(p::APL{S}) where {S}
+Base.convert(::Type{T}, p::_APL) where {T<:Number} = convert_to_constant(T, p)
+function convert_to_constant(p::_APL{S}) where {S}
     return convert_to_constant(S, p)
 end
 
-# Also covers, e.g., `convert(APL, ::P)` where `P<:APL`
-Base.convert(::Type{PT}, p::PT) where {PT<:APL} = p
+# Also covers, e.g., `convert(_APL, ::P)` where `P<:_APL`
+Base.convert(::Type{PT}, p::PT) where {PT<:_APL} = p

src/deprecate.jl

@@ -34,23 +34,23 @@ function changecoefficienttype(::Type{P}, ::Type{T}) where {P,T}
     return similar_type(P, T)
 end
 
-function changecoefficienttype(poly::APL, ::Type{T}) where {T}
+function changecoefficienttype(poly::_APL, ::Type{T}) where {T}
     Base.depwarn(
         "`changecoefficienttype(poly, T::Type)` is deprecated, use `similar(poly, T)` instead",
         :changecoefficienttype,
     )
     return similar(poly, T)
 end
 
-function mapcoefficientsnz(f::F, p::APL) where {F<:Function}
+function mapcoefficientsnz(f::F, p::_APL) where {F<:Function}
     Base.depwarn(
         "`mapcoefficientsnz(f, p)` is deprecated, use `map_coefficients(f, p, nonzero = true)` instead",
         :map_coefficientsnz,
     )
     return map_coefficients(f, p, nonzero = true)
 end
 
-function mapcoefficientsnz_to!(output::APL, f::F, p::APL) where {F<:Function}
+function mapcoefficientsnz_to!(output::_APL, f::F, p::_APL) where {F<:Function}
     Base.depwarn(
         "`mapcoefficientsnz_to!(output, f, p)` is deprecated, use `map_coefficients_to!(output, f, p, nonzero = true)` instead",
         :map_coefficientsnz_to!,

src/differentiation.jl

@@ -1,5 +1,3 @@
-export differentiate
-
 """
     differentiate(p::AbstractPolynomialLike, v::AbstractVariable, deg::Union{Int, Val}=1)
 
@@ -39,33 +37,33 @@ function differentiate(t::AbstractTermLike, v::AbstractVariable)
     return coefficient(t) * differentiate(monomial(t), v)
 end
 # The polynomial function will take care of removing the zeros
-function differentiate(p::APL, v::AbstractVariable)
+function differentiate(p::_APL, v::AbstractVariable)
     return polynomial!(differentiate.(terms(p), v), SortedState())
 end
 function differentiate(p::RationalPoly, v::AbstractVariable)
     return (differentiate(p.num, v) * p.den - p.num * differentiate(p.den, v)) /
            p.den^2
 end
 
-const ARPL = Union{APL,RationalPoly}
+const _ARPL = Union{_APL,RationalPoly}
 
 function differentiate(
     ps::AbstractArray{PT},
     xs::AbstractArray,
-) where {PT<:ARPL}
+) where {PT<:_ARPL}
     return differentiate.(reshape(ps, (size(ps)..., 1)), reshape(xs, 1, :))
 end
 
-function differentiate(ps::AbstractArray{PT}, xs::Tuple) where {PT<:ARPL}
+function differentiate(ps::AbstractArray{PT}, xs::Tuple) where {PT<:_ARPL}
     return differentiate(ps, collect(xs))
 end
 
 # TODO: this signature is probably too wide and creates the potential
 # for stack overflows
-differentiate(p::ARPL, xs) = [differentiate(p, x) for x in xs]
+differentiate(p::_ARPL, xs) = [differentiate(p, x) for x in xs]
 
 # differentiate(p, [x, y]) with TypedPolynomials promote x to a Monomial
-differentiate(p::ARPL, m::AbstractMonomial) = differentiate(p, variable(m))
+differentiate(p::_ARPL, m::AbstractMonomial) = differentiate(p, variable(m))
 
 # The `R` argument indicates a desired result type. We use this in order
 # to attempt to preserve type-stability even though the value of `deg` cannot