Fixes

Author: blegat

src/arithmetic.jl

@@ -2,6 +2,15 @@ const _APL = MP.AbstractPolynomialLike
 # We don't define it for all `AlgebraElement` as this would be type piracy
 const _AE = SA.AlgebraElement{<:SA.StarAlgebra{<:Variables}}
 
+function _polynomial(b::FullBasis{Monomial}, c::SA.SparseCoefficients)
+    return MP.polynomial(collect(SA.values(c)), MP.monomial.(getindex.(Ref(b), SA.keys(c))))
+end
+
+function MP.polynomial(a::SA.AlgebraElement)
+    b = FullBasis{Monomial}(MP.variables(a))
+    return _polynomial(b, SA.coeffs(a, b))
+end
+
 for op in [:+, :-, :*]
     @eval begin
         function MA.promote_operation(

src/monomial.jl

@@ -45,14 +45,14 @@ end
 SA.coeffs(p::Polynomial{Monomial}, ::FullBasis{Monomial}) = p.monomial
 
 function MP.polynomial_type(
-    ::Union{SubBasis{B,M},Type{<:SubBasis{B,M}}},
+    ::Union{SubBasis{B,V,E},Type{<:SubBasis{B,V,E}}},
     ::Type{T},
-) where {B,M,T}
-    return MP.polynomial_type(FullBasis{B,M}, T)
+) where {B,V,E,T}
+    return _polynomial_type(B, V, T)
 end
 
-function MP.polynomial_type(::Type{Polynomial{B,M}}, ::Type{T}) where {B,M,T}
-    return MP.polynomial_type(FullBasis{B,M}, T)
+function MP.polynomial_type(::Type{Polynomial{B,V,E}}, ::Type{T}) where {B,V,E,T}
+    return _polynomial_type(B, V, T)
 end
 
 function MP.polynomial(f::Function, mb::SubBasis{Monomial})
@@ -136,8 +136,12 @@ end
 
 _promote_coef(::Type{T}, ::Type{Monomial}) where {T} = T
 
-function MP.polynomial_type(::Type{FullBasis{B,M}}, ::Type{T}) where {T,B,M}
-    return MP.polynomial_type(M, _promote_coef(T, B))
+function MP.polynomial_type(::Type{<:FullBasis{B,V}}, ::Type{T}) where {T,B,V}
+    return _polynomial_type(B, V, T)
+end
+
+function _polynomial_type(::Type{B}, ::Type{V}, ::Type{T}) where {B, V, T}
+    return MP.polynomial_type(MP.monomial_type(V), _promote_coef(T, B))
 end
 
 _vec(v::Vector) = v

src/orthogonal.jl

@@ -108,7 +108,7 @@ function univariate_orthogonal_basis(
     return univariate_eval!(
         B,
         Vector{
-            MP.polynomial_type(Polynomial{B,MP.monomial_type(variable)}, Int),
+            _polynomial_type(B, typeof(MP.variables(variable)), Int),
         }(
             undef,
             degree + 1,
@@ -158,9 +158,9 @@ function explicit_basis_covering(
 end
 
 function explicit_basis_covering(
-    full::FullBasis{B,M},
-    monos::SubBasis{<:AbstractMonomial,M},
-) where {B<:AbstractMultipleOrthogonal,M}
+    full::FullBasis{B,V,E},
+    monos::SubBasis{<:AbstractMonomial,V,E},
+) where {B<:AbstractMultipleOrthogonal,V,E}
     return SA.SubBasis(full, _covering(full, monos.keys))
 end
 

src/polynomial.jl

@@ -102,7 +102,7 @@ end
 function _algebra_element(p, ::Type{B}) where {B<:AbstractMonomialIndexed}
     return algebra_element(
         sparse_coefficients(p),
-        FullBasis{B,MP.monomial_type(typeof(p))}(MP.variables(p)),
+        FullBasis{B}(MP.variables(p)),
     )
 end
 
@@ -158,15 +158,6 @@ function convert_basis(basis::SA.AbstractBasis, p::SA.AlgebraElement)
     return SA.AlgebraElement(SA.coeffs(p, basis), algebra(basis))
 end
 
-function _polynomial(b::FullBasis{Monomial}, c::SA.SparseCoefficients)
-    return MP.polynomial(collect(SA.values(c)), MP.monomial.(getindex.(Ref(b), SA.keys(c))))
-end
-
-function MP.polynomial(a::SA.AlgebraElement)
-    b = FullBasis{Monomial}(MP.variables(a))
-    return _polynomial(b, SA.coeffs(a, b))
-end
-
 function Base.isapprox(
     p::MP.AbstractPolynomialLike,
     a::SA.AlgebraElement;