Add Fixed basis

Author: blegat

src/MultivariateBases.jl

@@ -82,5 +82,6 @@ function MA.promote_operation(
 end
 
 include("arithmetic.jl")
+include("fixed.jl")
 
 end # module

src/arithmetic.jl

@@ -76,6 +76,18 @@ for op in [:+, :-]
     end
 end
 
+function term_element(α, p::Polynomial{B,M}) where {B,M}
+    return algebra_element(
+        sparse_coefficients(MP.term(α, p.monomial)),
+        FullBasis{B,M}(),
+    )
+end
+
+# Needed by `SymbolicWedderburn` which multiplies elements of the basis by `Int`
+# We'll see if `::Number` is too restrictive
+# Should be able to remove once https://github.com/kalmarek/SymbolicWedderburn.jl/issues/88 is closed
+Base.:*(α::Number, p::Polynomial) = term_element(α, p)
+
 function MA.operate!(op::Union{typeof(+),typeof(-),typeof(*)}, p::_APL, q::_AE)
     return MA.operate!(op, p, MP.polynomial(q))
 end

src/fixed.jl

@@ -0,0 +1,42 @@
+struct FixedPolynomialBasis{B,M,T,V} <: SA.ExplicitBasis{
+    SA.AlgebraElement{Algebra{FullBasis{B,M},B,M},T,V},
+    Int,
+}
+    elements::Vector{SA.AlgebraElement{Algebra{FullBasis{B,M},B,M},T,V}}
+end
+
+Base.length(b::FixedPolynomialBasis) = length(b.elements)
+Base.getindex(b::FixedPolynomialBasis, i::Integer) = b.elements[i]
+
+function Base.show(io::IO, b::FixedPolynomialBasis)
+    print(io, "FixedPolynomialBasis(")
+    _show_vector(io, MIME"text/plain"(), b.elements)
+    print(io, ")")
+    return
+end
+
+struct SemisimpleBasis{T,I,B<:SA.ExplicitBasis{T,I}} <: SA.ExplicitBasis{T,I}
+    bases::Vector{B}
+end
+
+Base.length(b::SemisimpleBasis) = length(first(b.bases))
+
+struct MultiPoly{P}
+    polynomials::Vector{P}
+end
+SA.star(p::MultiPoly) = MultiPoly(SA.star.(p.polynomials))
+
+Base.getindex(b::SemisimpleBasis, i::Integer) = MultiPoly(getindex.(b.bases, i))
+
+function Base.show(io::IO, b::SemisimpleBasis)
+    if length(b.bases) == 1
+        print(io, "Simple basis:")
+    else
+        print(io, "Semisimple basis with $(length(b.bases)) simple sub-bases:")
+    end
+    for basis in b.bases
+        println(io)
+        print(io, "  ")
+        print(io, basis)
+    end
+end

src/monomial.jl

@@ -258,20 +258,26 @@ function constant_algebra_element(::Type{<:SubBasis{B,M}}, α) where {B,M}
     )
 end
 
-function _show(io::IO, mime::MIME, basis::SubBasis{B}) where {B}
-    print(io, "SubBasis{$(nameof(B))}")
-    print(io, "([")
+# TODO use Base.show_vector here, maybe by wrapping the `generator` vector
+#      into something that spits objects wrapped with the `mime` type
+function _show_vector(io::IO, mime::MIME, v)
+    print(io, '[')
     first = true
-    # TODO use Base.show_vector here, maybe by wrapping the `generator` vector
-    #      into something that spits objects wrapped with the `mime` type
-    for mono in basis.monomials
+    for el in v
         if !first
             print(io, ", ")
         end
         first = false
-        show(io, mime, mono)
+        show(io, mime, el)
     end
-    return print(io, "])")
+    print(io, ']')
+end
+
+function _show(io::IO, mime::MIME, basis::SubBasis{B}) where {B}
+    print(io, "SubBasis{$(nameof(B))}(")
+    _show_vector(io, mime, basis.monomials)
+    print(io, ')')
+    return
 end
 
 function Base.show(io::IO, mime::MIME"text/plain", basis::SubBasis)
@@ -449,7 +455,7 @@ function SA.coeffs(
         return SA.SparseCoefficients(_vec(source.monomials), _vec(cfs))
     else
         res = SA.zero_coeffs(
-            _promote_coef(_promote_coef(valtype(cfs), B1), B2),
+            _promote_coef(_promote_coef(SA.value_type(cfs), B1), B2),
             target,
         )
         return SA.coeffs!(res, cfs, source, target)

src/polynomial.jl

@@ -1,7 +1,7 @@
 # TODO Add to MultivariatePolynomials
 MP.variables(p::SA.AlgebraElement) = MP.variables(explicit_basis(p))
 Base.keytype(p::MP.AbstractPolynomialLike) = MP.monomial_type(p)
-Base.valtype(p::MP.AbstractPolynomialLike) = MP.coefficient_type(p)
+SA.value_type(p::MP.AbstractPolynomialLike) = MP.coefficient_type(p)
 #Base.keys(p::MP.AbstractPolynomial) = MP.monomials(p)
 SA.nonzero_pairs(p::MP.AbstractPolynomialLike) = MP.terms(p)
 function Base.similar(p::PT, ::Type{T}) where {PT<:MP.AbstractPolynomial,T}

test/monomial.jl

@@ -14,7 +14,7 @@ using DynamicPolynomials
     @test MB.Polynomial{MB.Monomial}(x^3) != MB.Polynomial{MB.Monomial}(x^2)
 end
 
-@testset "Linear" begin
+#@testset "Linear" begin
     basis = SubBasis{MB.Monomial}([x, y])
     @test basis == SubBasis{MB.Monomial}([y, x])
     @test basis != SubBasis{MB.Monomial}([y, y^2, x])
@@ -33,7 +33,7 @@ end
     @test sprint(show, MIME"text/plain"(), basis) ==
           "SubBasis{Monomial}([y, x])"
     @test sprint(print, basis) == "SubBasis{Monomial}([y, x])"
-end
+#end
 @testset "Affine" begin
     # It will be sorted and 1 will be moved at the end
     basis = SubBasis{MB.Monomial}([1, x, y])