change parametric types of structs

Author: vitktor

src/lie-groups/lie-algebras/algebras.jl

@@ -17,7 +17,7 @@ dim(alg::ScalingLieAlgebra) = size(alg.exps, 1)
 exponents(alg::ScalingLieAlgebra) = alg.exps
 rank(alg::ScalingLieAlgebra) = dim(alg)
 Base.size(alg::ScalingLieAlgebra) = size(alg.exps, 2)
-weight_type(::ScalingLieAlgebra) = Int
+weight_type(::ScalingLieAlgebra) = Weight{Int}
 
 function show_basis(io::IO, alg::ScalingLieAlgebra; offset::Int=0)
     for i in 1:dim(alg)
@@ -92,8 +92,8 @@ Base.convert(
 struct LieAlgebra{F, W<:Weight} <: AbstractLieAlgebra{F}
     name::String
     basis::ChevalleyBasis{F}
-    weight_structure::WeightStructure{F, MatrixVectorSpace{F}, W}
-    hw_spaces::Vector{WeightSpace{F, MatrixVectorSpace{F}, W}} # TODO: change to WeightStructure?
+    weight_structure::WeightStructure{MatrixVectorSpace{F}, W}
+    hw_spaces::Vector{WeightSpace{MatrixVectorSpace{F}, W}} # TODO: change to WeightStructure?
 end
 
 function so3(field_type::DataType, weight_type::DataType)
@@ -125,7 +125,7 @@ name(alg::LieAlgebra) = alg.name
 dim(alg::LieAlgebra) = length(alg.basis.std_basis)
 rank(alg::LieAlgebra) = length(alg.basis.cartan)
 Base.size(alg::LieAlgebra) = size(alg.basis.std_basis[1], 1)
-weight_type(::LieAlgebra{F, Weight{W}}) where {F, W} = W
+weight_type(::LieAlgebra{F, W}) where {F, W} = W
 
 function Base.show(io::IO, alg::LieAlgebra{F, Weight{W}}; offset::Int=0) where {F, W}
     println(io, " "^offset, "LieAlgebra $(name(alg))")
@@ -221,6 +221,6 @@ cartan_subalgebra(alg::SumLieAlgebra) = get_elements(alg, :cartan_subalgebra)
 positive_root_elements(alg::SumLieAlgebra) = get_elements(alg, :positive_root_elements)
 negative_root_elements(alg::SumLieAlgebra) = get_elements(alg, :negative_root_elements)
 
-zero_weight(alg::AbstractLieAlgebra) = Weight(zeros(weight_type(alg), rank(alg)))
+zero_weight(alg::AbstractLieAlgebra) = zero(weight_type(alg), rank(alg))
 positive_roots(alg::AbstractLieAlgebra) = [root(pre) for pre in positive_root_elements(alg)]
 negative_roots(alg::AbstractLieAlgebra) = [root(nre) for nre in negative_root_elements(alg)]

src/lie-groups/lie-algebras/weights.jl

@@ -15,13 +15,14 @@ end
 
 Base.show(io::IO, ::MIME"text/plain", w::Weight) = print(io, "Weight: ", w.weight)
 Base.show(io::IO, w::Weight) = print(io, w.weight)
-Base.zero(::Type{Weight{T}}) where T = Weight(zero(T))
+Base.zero(::Type{Weight{T}}, n) where T = Weight(zeros(T, n))
 Base.zero(w::Weight) = Weight(zero(w.weight))
 Base.vcat(w₁::Weight{T}, w₂::Weight{T}) where T = Weight(vcat(w₁.weight, w₂.weight))
 Base.hash(w::Weight, h::UInt) = hash(w.weight, h)
 Base.:(==)(w₁::Weight, w₂::Weight) = w₁.weight == w₂.weight
 Base.:*(n::Number, w::Weight) = Weight(n*w.weight)
 Base.:+(w₁::Weight{T}, w₂::Weight{T}) where {T} = Weight{T}(w₁.weight + w₂.weight)
+Base.promote_rule(::Type{Weight{T}}, ::Type{Weight{S}}) where {T,S} = Weight{promote_type(T, S)}
 
 struct WeightVector{T, W<:Weight}
     weight::W
@@ -40,25 +41,26 @@ function Base.show(io::IO, wv::WeightVector)
     print(io, "WeightVector with weight $(weight(wv))")
 end
 
-struct WeightSpace{F, T <: AbstractVectorSpace{F}, W<:Weight} # TODO: remove F?
+struct WeightSpace{T <: AbstractVectorSpace, W<:Weight}
     weight::W
     space::T
 end
 
 WeightSpace(weight::Vector, space::Vector) = WeightSpace(Weight(weight), MatrixVectorSpace(space))
-WeightSpace{F,T,W}(wv::WeightVector) where {F,T,W} = WeightSpace{F,T,W}(weight(wv), T(vector(wv)))
+WeightSpace{T,W}(wv::WeightVector) where {T,W} = WeightSpace{T,W}(weight(wv), T(vector(wv)))
 
 Base.convert(
-    ::Type{WeightSpace{F, T, W}},
+    ::Type{WeightSpace{T, W}},
     ws::WeightSpace
-) where {F, T<:AbstractVectorSpace{F}, W<:Weight} = WeightSpace(
+) where {T<:AbstractVectorSpace, W<:Weight} = WeightSpace(
     convert(W, weight(ws)),
     convert(T, space(ws))
 )
 
 weight(ws::WeightSpace) = ws.weight
 space(ws::WeightSpace) = ws.space
 dim(ws::WeightSpace) = dim(space(ws))
+field_type(::WeightSpace{T}) where {T} = field_type(T)
 
 function Base.show(io::IO, ::MIME"text/plain", ws::WeightSpace)
     println(io, "WeightSpace of dimension $(dim(ws))")
@@ -74,12 +76,12 @@ function Base.iterate(ws::WeightSpace, state=1)
     return (WeightVector(weight(ws), basis(space(ws), state)), state+1)
 end
 
-struct WeightStructure{F, T<:AbstractVectorSpace{F}, W<:Weight}
+struct WeightStructure{T<:AbstractVectorSpace, W<:Weight}
     weights::Vector{W} # Ordering needed for sym_weight_structure
-    dict::Dict{W, WeightSpace{F, T, W}} # TODO: new type for WeightSpace{F,T,W}? Do all spaces have to be of the same type?
+    dict::Dict{W, WeightSpace{T, W}} # TODO: new type for WeightSpace{F,T,W}? Do all spaces have to be of the same type?
 end
 
-WeightStructure{F,T,W}() where {F,T,W} = WeightStructure{F,T,W}(Weight[], Dict())
+WeightStructure{T,W}() where {T,W} = WeightStructure{T,W}(Weight[], Dict())
 
 WeightStructure(
     weights::Vector{<:Weight},
@@ -98,27 +100,31 @@ WeightStructure(
 )
 
 # TODO: improve
-function WeightStructure(w_spaces::Vector{<:WeightSpace{F,T,W}}) where {F,T,W}
-    ws = WeightStructure{F,T,W}()
+function WeightStructure(w_spaces::Vector{<:WeightSpace{T,W}}) where {T,W}
+    ws = WeightStructure{T,W}()
     for w_space in w_spaces
         push!(ws, w_space)
     end
     return ws
 end
 
 Base.convert(
-    ::Type{WeightStructure{F, T, W}},
+    ::Type{WeightStructure{T, W}},
     ws::WeightStructure
-) where {F, T<:AbstractVectorSpace{F}, W<:Weight} = WeightStructure(
+) where {T<:AbstractVectorSpace, W<:Weight} = WeightStructure(
     convert(Vector{W}, ws.weights),
-    convert(Dict{W, WeightSpace{F, T, W}}, ws.dict)
+    convert(Dict{W, WeightSpace{T, W}}, ws.dict)
 )
 
 weights(ws::WeightStructure) = ws.weights
 weights(ws::WeightStructure, inds...) = getindex(weights(ws), inds...)
 nweights(ws::WeightStructure) = length(ws.weights)
-weight(ws::WeightStructure, i::Integer) = weights(ws)[i]
-weight_space(ws::WeightStructure, i::Integer) = ws[weight(ws, i)]
+weight(ws::WeightStructure, i::Integer) = weights(ws)[i] # TODO: remove?
+weight_space(
+    ws::WeightStructure,
+    i::Integer;
+    as_space::Bool=false
+) = as_space ? space(ws[weight(ws, i)]) : ws[weight(ws, i)]
 weight_spaces(
     ws::WeightStructure;
     as_spaces::Bool=false
@@ -131,12 +137,14 @@ weight_spaces(
 dims(ws::WeightStructure) = [dim(space(ws[w])) for w in weights(ws)]
 dim(ws::WeightStructure) = sum(dims(ws))
 Base.length(ws::WeightStructure) = nweights(ws)
-Base.getindex(ws::WeightStructure{F,T,W}, weight::W) where {F,T,W<:Weight} = ws.dict[weight]
+Base.isempty(ws::WeightStructure) = isempty(weights(ws))
+Base.getindex(ws::WeightStructure{T,W}, weight::W) where {T,W<:Weight} = ws.dict[weight]
 Base.getindex(ws::WeightStructure, i::Integer) = ws[weight(ws, i)]
 Base.setindex!(ws::WeightStructure, ws_new::WeightSpace, weight::Weight) = ws.dict[weight] = ws_new
 Base.haskey(ws::WeightStructure, w::Weight) = haskey(ws.dict, w)
 zero_weight(ws::WeightStructure) = zero(first(weights(ws)))
-field_space(::WeightStructure{F, T}) where {F, T} = field_space(T)
+field_space(::WeightStructure{T}) where {T} = field_space(T)
+field_type(::WeightStructure{T}) where {T} = field_type(T)
 
 function Base.show(io::IO, ::MIME"text/plain", ws::WeightStructure)
     println(io, "WeightStructure of $(dim(ws))-dimensional vector space")
@@ -165,9 +173,9 @@ function Base.push!(ws::WeightStructure, w_space::WeightSpace)
     return ws
 end
 
-Base.push!(ws::WeightStructure{F,T,W}, wv::WeightVector) where {F,T,W} = push!(ws, WeightSpace{F,T,W}(wv))
+Base.push!(ws::WeightStructure{T,W}, wv::WeightVector) where {T,W} = push!(ws, WeightSpace{T,W}(wv))
 
-function sym(ws::WeightStructure{F,T,W}, d::Int) where {F, T, W}
+function sym(ws::WeightStructure{T,W}, d::Int) where {T, W}
     d == 0 && return WeightStructure([WeightSpace(zero_weight(ws), field_space(ws))])
     d == 1 && return ws
     combs = multiexponents(; degree=d, nvars=nweights(ws))
@@ -180,10 +188,31 @@ function sym(ws::WeightStructure{F,T,W}, d::Int) where {F, T, W}
             new_weights_dict[w] = [comb]
         end
     end
-    new_ws = WeightStructure{F,T,W}()
+    new_ws = WeightStructure{T,W}()
     for (weight, combs) in new_weights_dict
         w_sps = [*(weight_spaces(ws, comb.nzind; as_spaces=true), comb.nzval) for comb in combs]
         push!(new_ws, WeightSpace(weight, +(w_sps...)))
     end
     return new_ws
+end
+
+function tensor(ws₁::WeightStructure{T,W}, ws₂::WeightStructure{T,W}) where {T, W}
+    combs = Base.Iterators.product(1:nweights(ws₁), 1:nweights(ws₂))
+    new_weights_dict = Dict{W, Vector{typeof(first(combs))}}()
+    for comb in combs
+        w = weight(ws₁, comb[1]) + weight(ws₂, comb[2])
+        val = get(new_weights_dict, w, nothing)
+        if isnothing(val)
+            new_weights_dict[w] = [comb]
+        else
+            push!(new_weights_dict[w], comb)
+        end
+    end
+    new_ws = WeightStructure{T,W}()
+    for (weight, combs) in new_weights_dict
+        w_sps = [*([weight_space(ws₁, comb[1]; as_space=true), weight_space(ws₂, comb[2]; as_space=true)]; in_rref=false) for comb in combs]
+        total_ws = +(w_sps...; in_rref=false)
+        push!(new_ws, WeightSpace(weight, total_ws))
+    end
+    return new_ws
 end

src/vector-spaces/basic.jl

@@ -3,7 +3,7 @@ export MatrixVectorSpace,
     VariableSpace
 
 
-struct MatrixVectorSpace{F} <: AbstractVectorSpace{F}
+struct MatrixVectorSpace{F} <: AbstractVectorSpace{Vector{F}, F}
     matrix::Matrix{F}
 end
 
@@ -27,15 +27,15 @@ function Base.:∩(V₁::MatrixVectorSpace, V₂::MatrixVectorSpace)
 end
 
 # TODO: add gens?
-struct VectorSpace{T, F} <: AbstractVectorSpace{F}
+struct VectorSpace{T, F} <: AbstractVectorSpace{T, F}
     basis::Vector{T}
 end
 
 VectorSpace{T, F}() where {T, F} = VectorSpace{T, F}(Vector{T}())
 VectorSpace{T, F}(v::T) where {T, F} = VectorSpace{T, F}([v])
 VectorSpace(F::DataType, vars::Vector{T}) where T<:Variable = VectorSpace{T, F}(unique(vars))
 VectorSpace(F::DataType, vs::Vector{T}) where T = VectorSpace{T, F}(vs)
-VectorSpace(F::DataType, polys::Vector{T}) where T<:Polynomial = VectorSpace{T,F}(in_rref(polys))
+VectorSpace(F::DataType, polys::Vector{T}) where T<:Polynomial = VectorSpace{T,F}(rref(polys))
 
 basis(V::VectorSpace) = V.basis
 basis(V::VectorSpace, i::Integer) = basis(V)[i]
@@ -49,7 +49,10 @@ function Base.show(io::IO, V::VectorSpace{T, F}; indent::Int=0) where {T, F}
 end
 
 field_space(::Type{VectorSpace{T, F}}) where {T, F} = VectorSpace{T, F}(one(T))
-variables(V::VectorSpace{<:Variable}) = basis(V)
+DynamicPolynomials.variables(V::VectorSpace{<:Variable}) = basis(V)
+DynamicPolynomials.nvariables(V::VectorSpace{<:Variable}) = dim(V)
+DynamicPolynomials.variables(V::VectorSpace{<:Polynomial}) = variables(basis(V))
+DynamicPolynomials.nvariables(V::VectorSpace{<:Polynomial}) = nvariables(basis(V))
 Base.iszero(V::VectorSpace) = dim(V) == 0
 Base.rand(V::VectorSpace{T, F}) where {T, F} = sum(rand(F, dim(V)) .* basis(V))
 Base.push!(V::VectorSpace{T}, v::T) where T = push!(V.basis, v)
@@ -58,13 +61,25 @@ Base.convert(::Type{VectorSpace{T₁, F}}, V::VectorSpace{T₂, F}) where {T₁,
 Base.:+(
     Vs::VectorSpace{T, F}...
 ) where {T<:Variable, F} = VectorSpace{T,F}(∪([basis(V) for V in Vs]...))
-Base.:+(
-    Vs::VectorSpace{T, F}...
-) where {T<:Polynomial, F} = VectorSpace{T,F}(in_rref(vcat([basis(V) for V in Vs]...)))
 
-Base.:*(
-    Vs::Vector{VectorSpace{T, F}}
-) where {T<:Polynomial, F} = VectorSpace{T, F}(in_rref([prod(fs) for fs in product([basis(V) for V in Vs]...)][:]))
+function Base.:+(
+    Vs::VectorSpace{T, F}...;
+    in_rref::Bool=true
+) where {T<:Polynomial, F}
+    if in_rref
+        return VectorSpace{T,F}(rref(vcat([basis(V) for V in Vs]...)))
+    end
+    return VectorSpace{T,F}(vcat([basis(V) for V in Vs]...))
+end
+
+function Base.:*(
+    Vs::Vector{VectorSpace{T, F}};
+    in_rref::Bool=true
+) where {T<:Polynomial, F}
+    in_rref && return VectorSpace{T, F}(rref([prod(fs) for fs in product([basis(V) for V in Vs]...)][:]))
+    return VectorSpace{T, F}([prod(fs) for fs in product([basis(V) for V in Vs]...)][:])
+end
+
 Base.:*(
     Vs::Vector{VectorSpace{T, F}},
     muls::Vector{Int}
@@ -85,9 +100,3 @@ function Base.:∩(
     Vᵢ = M₁*N[1:dim(V₁), :]
     return VectorSpace(F, [sum(c .* all_mons) for c in eachcol(Vᵢ)])
 end
-
-function zero_combinations(F::Vector{<:AbstractPolynomial}; tol::Real=1e-5)
-    mons = monomials(F)
-    M = coeffs_matrix(F, mons)
-    return eachcol(nullspace(M; atol=tol))
-end