Update to MultivariatePolynomials v0.5

Project.toml

@@ -32,10 +32,10 @@ Combinatorics = "1.0"
 ConstructionBase = "1.1"
 DataStructures = "0.18"
 DocStringExtensions = "0.8, 0.9"
-DynamicPolynomials = "0.3, 0.4"
+DynamicPolynomials = "0.5"
 IfElse = "0.1"
 LabelledArrays = "1.5"
-MultivariatePolynomials = "0.3, 0.4"
+MultivariatePolynomials = "0.5"
 NaNMath = "0.3, 1"
 Setfield = "0.7, 0.8, 1"
 SpecialFunctions = "0.10, 1.0, 2"

docs/src/manual/representation.md

@@ -23,7 +23,7 @@ $p / q$ is represented by `Div(p, q)`. The result of `*` on `Div` is maintainted
 
 Packages like DynamicPolynomials.jl provide representations that are even more efficient than the `Add` and `Mul` types mentioned above. They are designed specifically for multi-variate polynomials. They provide common algorithms such as multi-variate polynomial GCD. The restrictions that make it fast also mean some things are not possible: Firstly, DynamicPolynomials can only represent flat polynomials. For example, `(x-3)*(x+5)` can only be represented as `(x^2) + 15 - 8x`. Secondly, DynamicPolynomials does not have ways to represent generic Terms such as `sin(x-y)` in the tree.
 
-To reconcile these differences while being able to use the efficient algorithms of DynamicPolynomials we have the `PolyForm` type. This type holds a polynomial and the mappings necessary to present the polynomial as a SymbolicUtils expression (i.e. by defining `operation` and `arguments`).  The mappings constructed for the conversion are 1) a bijection from DynamicPolynomials PolyVar type to a Symbolics `Sym`, and 2) a mapping from `Sym`s to non-polynomial terms that the `Sym`s stand-in for. These terms may themselves contain PolyForm if there are polynomials inside them. The mappings are transiently global, that is, when all references to the mappings go out of scope, they are released and re-created.
+To reconcile these differences while being able to use the efficient algorithms of DynamicPolynomials we have the `PolyForm` type. This type holds a polynomial and the mappings necessary to present the polynomial as a SymbolicUtils expression (i.e. by defining `operation` and `arguments`).  The mappings constructed for the conversion are 1) a bijection from DynamicPolynomials Variable type to a Symbolics `Sym`, and 2) a mapping from `Sym`s to non-polynomial terms that the `Sym`s stand-in for. These terms may themselves contain PolyForm if there are polynomials inside them. The mappings are transiently global, that is, when all references to the mappings go out of scope, they are released and re-created.
 
 ```julia
 julia> @syms x y

page/representation.md

@@ -23,7 +23,7 @@ $p / q$ is represented by `Div(p, q)`. The result of `*` on `Div` is maintainted
 
 Packages like DynamicPolynomials.jl provide representations that are even more efficient than the `Add` and `Mul` types mentioned above. They are designed specifically for multi-variate polynomials. They provide common algorithms such as multi-variate polynomial GCD. The restrictions that make it fast also mean some things are not possible: Firstly, DynamicPolynomials can only represent flat polynomials. For example, `(x-3)*(x+5)` can only be represented as `(x^2) + 15 - 8x`. Secondly, DynamicPolynomials does not have ways to represent generic Terms such as `sin(x-y)` in the tree.
 
-To reconcile these differences while being able to use the efficient algorithms of DynamicPolynomials we have the `PolyForm` type. This type holds a polynomial and the mappings necessary to present the polynomial as a SymbolicUtils expression (i.e. by defining `operation` and `arguments`).  The mappings constructed for the conversion are 1) a bijection from DynamicPolynomials PolyVar type to a Symbolics `Sym`, and 2) a mapping from `Sym`s to non-polynomial terms that the `Sym`s stand-in for. These terms may themselves contain PolyForm if there are polynomials inside them. The mappings are transiently global, that is, when all references to the mappings go out of scope, they are released and re-created.
+To reconcile these differences while being able to use the efficient algorithms of DynamicPolynomials we have the `PolyForm` type. This type holds a polynomial and the mappings necessary to present the polynomial as a SymbolicUtils expression (i.e. by defining `operation` and `arguments`).  The mappings constructed for the conversion are 1) a bijection from DynamicPolynomials Variable type to a Symbolics `Sym`, and 2) a mapping from `Sym`s to non-polynomial terms that the `Sym`s stand-in for. These terms may themselves contain PolyForm if there are polynomials inside them. The mappings are transiently global, that is, when all references to the mappings go out of scope, they are released and re-created.
 
 ```julia
 julia> @syms x y

src/SymbolicUtils.jl

@@ -40,8 +40,7 @@ include("matchers.jl")
 include("rewriters.jl")
 
 # Convert to an efficient multi-variate polynomial representation
-import MultivariatePolynomials
-const MP = MultivariatePolynomials
+import MultivariatePolynomials as MP
 import DynamicPolynomials
 export expand
 include("polyform.jl")

src/polyform.jl

@@ -1,6 +1,5 @@
 export PolyForm, simplify_fractions, quick_cancel, flatten_fractions
 using Bijections
-using DynamicPolynomials: PolyVar
 
 """
     PolyForm{T} <: Symbolic
@@ -44,7 +43,7 @@ end
 Base.hash(p::PolyForm, u::UInt64) = xor(hash(p.p, u),  trunc(UInt, 0xbabacacababacaca))
 Base.isequal(x::PolyForm, y::PolyForm) = isequal(x.p, y.p)
 
-# We use the same PVAR2SYM bijection to maintain the PolyVar <-> Sym mapping,
+# We use the same PVAR2SYM bijection to maintain the MP.AbstractVariable <-> Sym mapping,
 # When all PolyForms go out of scope in a session, we allow it to free up memory and
 # start over if necessary
 const PVAR2SYM = Ref(WeakRef())
@@ -156,7 +155,7 @@ end
 function PolyForm(x,
         pvar2sym=get_pvar2sym(),
         sym2term=get_sym2term(),
-        vtype=DynamicPolynomials.PolyVar{true};
+        vtype=MP.AbstractVariable;
         Fs = Union{typeof(+), typeof(*), typeof(^)},
         recurse=false,
         metadata=metadata(x))