Large renaming (#251)

* Large renaming

* update ci

* Rename file monovec

* Update use of mapcoefficients_nz

* Update ci scripts

* Fixes

Author: blegat

.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
             os: ubuntu-latest
             arch: x64
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@v1
         with:
           version: ${{ matrix.version }}
@@ -46,12 +46,12 @@ jobs:
         shell: julia --project=@. {0}
         run: |
           using Pkg
-          Pkg.add(PackageSpec(name="TypedPolynomials", rev="bl/refactor"))
+          Pkg.add(PackageSpec(name="TypedPolynomials", rev="bl/rename"))
       - name: DP#master
         shell: julia --project=@. {0}
         run: |
           using Pkg
-          Pkg.add(PackageSpec(name="DynamicPolynomials", rev="master"))
+          Pkg.add(PackageSpec(name="DynamicPolynomials", rev="bl/rename"))
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
         with:

.github/workflows/documentation.yml

@@ -9,11 +9,11 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@latest
         with:
-          # Build documentation on Julia 1.0
-          version: '1.0'
+          # Build documentation on latest release
+          version: '1'
       - name: Install dependencies
         run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
       - name: Build and deploy

README.md

@@ -5,6 +5,8 @@
 | [![][docs-stable-img]][docs-stable-url] | [![Build Status][build-img]][build-url] | [![Gitter][gitter-img]][gitter-url] | [![DOI][zenodo-img]][zenodo-url] |
 | [![][docs-latest-img]][docs-latest-url] | [![Codecov branch][codecov-img]][codecov-url] | [<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Discourse_logo.png/799px-Discourse_logo.png" width="64">][discourse-url] | |
 
+**WARNING** MultivariatePolynomials v0.5 has a few breaking changes including the change in the order of monomials. This means that the leading term will now appear last in the order of monomials instead of first.
+
 This package provides an interface for manipulating multivariate polynomials.
 Implementing algorithms on polynomials using this interface will allow the algorithm to work for all polynomials implementing the interface.
 

docs/src/types.md

@@ -12,25 +12,25 @@ variable
 name
 name_base_indices
 variable_union_type
-similarvariable
-@similarvariable
+similar_variable
+@similar_variable
 ```
 
 ## Monomials
 
 ```@docs
 AbstractMonomialLike
 AbstractMonomial
-monomialtype
+monomial_type
 variables
 effective_variables
 nvariables
 exponents
 degree
 isconstant
 powers
-constantmonomial
-mapexponents
+constant_monomial
+map_exponents
 ```
 
 ## Terms
@@ -39,12 +39,12 @@ mapexponents
 AbstractTermLike
 AbstractTerm
 term
-termtype
+term_type
 coefficient
 coefficienttype
 monomial
-constantterm
-zeroterm
+constant_term
+zero_term
 ```
 
 ## Polynomials
@@ -53,7 +53,7 @@ zeroterm
 AbstractPolynomialLike
 AbstractPolynomial
 polynomial
-polynomialtype
+polynomial_type
 terms
 nterms
 coefficients
@@ -63,15 +63,15 @@ ordering
 mindegree
 maxdegree
 extdegree
-leadingterm
-leadingcoefficient
-leadingmonomial
-removeleadingterm
-removemonomials
+leading_term
+leading_coefficient
+leading_monomial
+remove_leading_term
+remove_monomials
 monic
-mapcoefficients
-mapcoefficients!
-mapcoefficients_to!
+map_coefficients
+map_coefficients!
+map_coefficients_to!
 ```
 
 ## Rational Polynomial Function
@@ -82,9 +82,9 @@ The numerator and denominator polynomials can be retrieved by the `numerator` an
 ## Monomial Vectors
 
 ```@docs
-monovec
-monovectype
-emptymonovec
-sortmonovec
-mergemonovec
+monomial_vector
+monomial_vector_type
+empty_monomial_vector
+sort_monomial_vector
+merge_monomial_vectors
 ```

src/MultivariatePolynomials.jl

@@ -4,10 +4,10 @@ import LinearAlgebra
 
 import DataStructures
 
-import MutableArithmetics
-const MA = MutableArithmetics
+import MutableArithmetics as MA
 
 export AbstractPolynomialLike, AbstractTermLike, AbstractMonomialLike
+
 """
     AbstractPolynomialLike{T}
 
@@ -69,7 +69,7 @@ include("variable.jl")
 include("monomial.jl")
 include("term.jl")
 include("polynomial.jl")
-include("monovec.jl")
+include("monomial_vector.jl")
 include("ordering.jl")
 
 include("rational.jl")
@@ -95,4 +95,6 @@ include("default_term.jl")
 include("sequences.jl")
 include("default_polynomial.jl")
 
+include("deprecate.jl")
+
 end # module

src/comparison.jl

@@ -23,15 +23,15 @@ Base.:(==)(x::RationalPoly, α::Nothing) = false
 Base.:(==)(α::Dict, x::RationalPoly) = false
 Base.:(==)(x::RationalPoly, α::Dict) = false
 
-function polyeqterm(p::AbstractPolynomial, t)
+function right_term_eq(p::AbstractPolynomial, t)
     if iszero(p)
         iszero(t)
     else
         # terms/nterms ignore zero terms
-        nterms(p) == 1 && leadingterm(p) == t
+        nterms(p) == 1 && leading_term(p) == t
     end
 end
-polyeqterm(p::APL, t) = polyeqterm(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
@@ -44,8 +44,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) = polyeqterm(p, α)
-right_constant_eq(p::APL, α) = polyeqterm(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
@@ -69,8 +69,8 @@ function Base.:(==)(t1::AbstractTerm, t2::AbstractTerm)
         c1 == c2 && monomial(t1) == monomial(t2)
     end
 end
-Base.:(==)(p::AbstractPolynomial, t::AbstractTerm) = polyeqterm(p, t)
-Base.:(==)(t::AbstractTerm, p::AbstractPolynomial) = polyeqterm(p, t)
+Base.:(==)(p::AbstractPolynomial, t::AbstractTerm) = right_term_eq(p, t)
+Base.:(==)(t::AbstractTerm, p::AbstractPolynomial) = right_term_eq(p, t)
 
 function compare_terms(p1::AbstractPolynomial, p2::AbstractPolynomial, isz, op)
     i1 = 1
@@ -139,5 +139,5 @@ end
 Base.isapprox(p::RationalPoly, q::RationalPoly; kwargs...) = isapprox(p.num*q.den, q.num*p.den; kwargs...)
 Base.isapprox(p::RationalPoly, q::APL; kwargs...) = isapprox(p.num, q*p.den; kwargs...)
 Base.isapprox(p::APL, q::RationalPoly; kwargs...) = isapprox(p*q.den, q.num; kwargs...)
-Base.isapprox(q::RationalPoly{C}, α; kwargs...) where {C} = isapprox(q, constantterm(α, q.den); kwargs...)
-Base.isapprox(α, q::RationalPoly{C}; kwargs...) where {C} = isapprox(constantterm(α, q.den), q; kwargs...)
+Base.isapprox(q::RationalPoly{C}, α; kwargs...) where {C} = isapprox(q, constant_term(α, q.den); kwargs...)
+Base.isapprox(α, q::RationalPoly{C}; kwargs...) where {C} = isapprox(constant_term(α, q.den), q; kwargs...)

src/conversion.jl

@@ -1,12 +1,12 @@
 export variable, convert_to_constant
 
-function convertconstant end
-Base.convert(::Type{P}, α) where P<:APL = convertconstant(P, α)
-function convertconstant(::Type{TT}, α) where {T,TT<:AbstractTerm{T}}
-    return term(convert(T, α), constantmonomial(TT))
+function convert_constant end
+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 convertconstant(::Type{PT}, α) where {PT<:AbstractPolynomial}
-    return convert(PT, convert(termtype(PT), α))
+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}}
     error("`convert` not implemented for $P")
@@ -40,10 +40,10 @@ function Base.convert(::Type{M}, t::AbstractTerm) where M <: AbstractMonomialLik
     end
 end
 function Base.convert(TT::Type{<:AbstractTerm{T}}, m::AbstractMonomialLike) where T
-    return convert(TT, term(one(T), convert(monomialtype(TT), m)))
+    return convert(TT, term(one(T), convert(monomial_type(TT), m)))
 end
 function Base.convert(TT::Type{<:AbstractTerm{T}}, t::AbstractTerm) where T
-    return convert(TT, term(convert(T, coefficient(t)), convert(monomialtype(TT), monomial(t))))
+    return convert(TT, term(convert(T, coefficient(t)), convert(monomial_type(TT), monomial(t))))
 end
 
 # Base.convert(::Type{T}, t::T) where {T <: AbstractTerm} is ambiguous with above method.
@@ -54,9 +54,9 @@ end
 
 function Base.convert(::Type{T}, p::AbstractPolynomial) where T <: AbstractTermLike
     if iszero(nterms(p))
-        convert(T, zeroterm(p))
+        convert(T, zero_term(p))
     elseif isone(nterms(p))
-        convert(T, leadingterm(p))
+        convert(T, leading_term(p))
     else
         throw(InexactError(:convert, T, p))
     end