From 66a5f2e9b92ee28f958f331b2d062a45bae32325 Mon Sep 17 00:00:00 2001 From: antonydellavecchia Date: Tue, 19 Nov 2024 08:44:50 +0100 Subject: [PATCH] containers completed, need some upgrades though --- src/Serialization/Rings.jl | 46 +++++----- src/Serialization/basic_types.jl | 9 +- src/Serialization/containers.jl | 109 +++++++----------------- src/Serialization/main.jl | 32 ++++++- test/Serialization/PolynomialsSeries.jl | 4 +- test/Serialization/containers.jl | 4 +- 6 files changed, 93 insertions(+), 111 deletions(-) diff --git a/src/Serialization/Rings.jl b/src/Serialization/Rings.jl index 3c54dc7503fd..35895f703bb1 100644 --- a/src/Serialization/Rings.jl +++ b/src/Serialization/Rings.jl @@ -71,8 +71,8 @@ function load_object(s::DeserializerState, ::Type{ZZModRing}) end #elements -@register_serialization_type zzModRingElem uses_params -@register_serialization_type ZZModRingElem uses_params +@register_serialization_type zzModRingElem +@register_serialization_type ZZModRingElem function save_object(s::SerializerState, x::ModRingElemUnion) save_data_basic(s, string(x)) @@ -86,11 +86,11 @@ end ################################################################################ # Polynomial Rings -@register_serialization_type PolyRing uses_id uses_params -@register_serialization_type MPolyRing uses_id uses_params -@register_serialization_type UniversalPolyRing uses_id uses_params -@register_serialization_type MPolyDecRing uses_id uses_params -@register_serialization_type AbstractAlgebra.Generic.LaurentMPolyWrapRing uses_id uses_params +@register_serialization_type PolyRing uses_id +@register_serialization_type MPolyRing uses_id +@register_serialization_type UniversalPolyRing uses_id +@register_serialization_type MPolyDecRing uses_id +@register_serialization_type AbstractAlgebra.Generic.LaurentMPolyWrapRing uses_id function save_object(s::SerializerState, R::PolyRingUnionType) base = base_ring(R) @@ -135,10 +135,10 @@ end ################################################################################ # Polynomial Ring Elem Types -@register_serialization_type MPolyRingElem uses_params -@register_serialization_type MPolyDecRingElem uses_params -@register_serialization_type UniversalPolyRingElem uses_params -@register_serialization_type AbstractAlgebra.Generic.LaurentMPolyWrap uses_params +@register_serialization_type MPolyRingElem +@register_serialization_type MPolyDecRingElem +@register_serialization_type UniversalPolyRingElem +@register_serialization_type AbstractAlgebra.Generic.LaurentMPolyWrap # elements function save_object(s::SerializerState, p::Union{UniversalPolyRingElem, MPolyRingElem}) @@ -171,7 +171,7 @@ end ################################################################################ # Univariate Polynomials -@register_serialization_type PolyRingElem uses_params +@register_serialization_type PolyRingElem function save_object(s::SerializerState, p::PolyRingElem) coeffs = coefficients(p) @@ -251,8 +251,8 @@ end ################################################################################ # Polynomial Ideals -@register_serialization_type MPolyIdeal uses_params -@register_serialization_type LaurentMPolyIdeal uses_params +@register_serialization_type MPolyIdeal +@register_serialization_type LaurentMPolyIdeal function save_object(s::SerializerState, I::T) where T <: IdealOrdUnionType save_object(s, gens(I)) @@ -271,7 +271,7 @@ end # this will need adjustments to cover the NCRing case -@register_serialization_type IdealGens uses_params +@register_serialization_type IdealGens function save_object(s::SerializerState, obj::IdealGens) save_data_dict(s) do @@ -298,9 +298,9 @@ end ################################################################################ # Matrices @register_serialization_type MatSpace uses_id -@register_serialization_type MatElem uses_params +@register_serialization_type MatElem @register_serialization_type SMatSpace uses_id -@register_serialization_type SMat uses_params +@register_serialization_type SMat function save_object(s::SerializerState, obj::MatSpace) save_data_dict(s) do @@ -420,8 +420,8 @@ function load_object(s::DeserializerState, ::Type{<: SeriesRing}, base_ring::Rin end # elements -@register_serialization_type RelPowerSeriesRingElem uses_params -@register_serialization_type AbsPowerSeriesRingElem uses_params +@register_serialization_type RelPowerSeriesRingElem +@register_serialization_type AbsPowerSeriesRingElem function save_object(s::SerializerState, r::RelPowerSeriesRingElem) v = valuation(r) @@ -528,9 +528,9 @@ function load_object(s::DeserializerState, ::Type{<: LaurentUnionType}, base_rin end # elements -@register_serialization_type Generic.LaurentSeriesFieldElem "LaurentSeriesFieldElem" uses_params -@register_serialization_type Generic.LaurentSeriesRingElem "LaurentSeriesRingElem" uses_params -@register_serialization_type ZZLaurentSeriesRingElem uses_params +@register_serialization_type Generic.LaurentSeriesFieldElem "LaurentSeriesFieldElem" +@register_serialization_type Generic.LaurentSeriesRingElem "LaurentSeriesRingElem" +@register_serialization_type ZZLaurentSeriesRingElem function save_object(s::SerializerState, r:: Union{Generic.LaurentSeriesElem, ZZLaurentSeriesRingElem}) v = valuation(r) @@ -612,7 +612,7 @@ function load_object(s::DeserializerState, ::Type{MPolyQuoRing}) end ### Serialization of Monomial orderings -@register_serialization_type MonomialOrdering uses_params +@register_serialization_type MonomialOrdering function save_object(s::SerializerState, o::MonomialOrdering) save_data_dict(s) do diff --git a/src/Serialization/basic_types.jl b/src/Serialization/basic_types.jl index 945549d76970..d1cbfc8a65fe 100644 --- a/src/Serialization/basic_types.jl +++ b/src/Serialization/basic_types.jl @@ -3,6 +3,7 @@ function save_object(s::SerializerState, x::T) where T <: Union{BasicTypeUnion, end load_object(s::DeserializerState, T::Type, ::Nothing) = load_object(s, T) + ################################################################################ # Bool @register_serialization_type Bool @@ -23,7 +24,9 @@ end # ZZRingElem @register_serialization_type ZZRingElem -function load_object(s::DeserializerState, ::Type{ZZRingElem}, ::ZZRing) +load_object(s::DeserializerState, T::Type{ZZRingElem}, ::ZZRing) = load_object(s, T) + +function load_object(s::DeserializerState, ::Type{ZZRingElem}) load_node(s) do str return ZZRingElem(str) end @@ -33,7 +36,9 @@ end # QQFieldElem @register_serialization_type QQFieldElem -function load_object(s::DeserializerState, ::Type{QQFieldElem}, ::QQField) +load_object(s::DeserializerState, T::Type{QQFieldElem}, ::QQField) = load_object(s, T) + +function load_object(s::DeserializerState, ::Type{QQFieldElem}) # TODO: simplify the code below once https://github.com/Nemocas/Nemo.jl/pull/1375 # is merged and in a Nemo release load_node(s) do q diff --git a/src/Serialization/containers.jl b/src/Serialization/containers.jl index 28e4e639960b..f8e1a0863467 100644 --- a/src/Serialization/containers.jl +++ b/src/Serialization/containers.jl @@ -70,7 +70,7 @@ end ################################################################################ # Saving and loading matrices -@register_serialization_type Matrix uses_params +@register_serialization_type Matrix function save_object(s::SerializerState, mat::Matrix) m, n = size(mat) @@ -81,30 +81,30 @@ function save_object(s::SerializerState, mat::Matrix) end end -function load_object(s::DeserializerState, ::Type{<:Matrix}, params::Type) +function load_object(s::DeserializerState, T::Type{<:Matrix{S}}) where S load_node(s) do entries if isempty(entries) - return Matrix{params}(undef, 0, 0) + return T(undef, 0, 0) end len = length(entries) m = reduce(vcat, [ - permutedims(load_object(s, Vector, params, i)) for i in 1:len + permutedims(load_object(s, Vector{S}, i)) for i in 1:len ]) - return Matrix{params}(m) + return T(m) end end -function load_object(s::DeserializerState, ::Type{<:Matrix}, params::Tuple) +function load_object(s::DeserializerState, T::Type{<:Matrix{S}}, params::Ring) where S load_node(s) do entries if isempty(entries) - return Matrix{params[1]}(undef, 0, 0) + return T(undef, 0, 0) end len = length(entries) m = reduce(vcat, [ - permutedims(load_object(s, Vector, params, i)) for i in 1:len + permutedims(load_object(s, Vector{S}, params, i)) for i in 1:len ]) - return Matrix{params[1]}(m) + return Matrix{elem_type(params)}(m) end end @@ -177,21 +177,13 @@ function save_object(s::SerializerState, obj::Dict{S, T}) where {S <: Union{Symb end end -function save_object(s::SerializerState, obj::Dict) - save_data_array(s) do - for (k, v) in obj - save_object(s, (k, v)) - end - end -end - -function load_object(s::DeserializerState, ::Type{Dict{String, Int}}) - return Dict{String, Int}(string(k) => parse(Int, v) for (k,v) in s.obj) -end - -function load_object(s::DeserializerState, ::Type{Dict{Int, Int}}) - return Dict{Int, Int}(parse(Int,string(k)) => parse(Int, v) for (k,v) in s.obj) -end +#function save_object(s::SerializerState, obj::Dict) +# save_data_array(s) do +# for (k, v) in obj +# save_object(s, (k, v)) +# end +# end +#end function load_object(s::DeserializerState, T::Type{<:Dict{S, U}}, @@ -205,26 +197,14 @@ end ################################################################################ # Saving and loading sets -@register_serialization_type Set uses_params +@register_serialization_type Set -function save_type_params(s::SerializerState, obj::Set{T}) where T - save_data_dict(s) do - save_object(s, encode_type(Set), :name) - if serialize_with_params(T) && !isempty(obj) - save_type_params(s, first(obj), :params) - else - save_object(s, encode_type(T), :params) - end +function type_params(obj::T) where T <: Set + if isempty(obj) + return T, nothing end -end -function load_type_params(s::DeserializerState, ::Type{<:Set}) - T = decode_type(s) - if serialize_with_params(T) && haskey(s, :params) - params = load_params_node(s) - return (T, params) - end - return T + return T, type_params(first(obj)) end function save_object(s::SerializerState, x::Set) @@ -240,49 +220,18 @@ function save_object(s::SerializerState, x::Set) end end -function load_object(s::DeserializerState, ::Type{<: Set}, params::Any) - load_node(s) do v - if serialize_with_id(params) - loaded_v = params[load_ref(s, x) for x in v] - else - loaded_v = params[] - for (i, entry) in enumerate(v) - push!(loaded_v, load_object(s, params, i)) - end - end - return Set(loaded_v) - end -end - -# handles nested -function load_object(s::DeserializerState, ::Type{<: Set}, params::Tuple) - T = params[1] - load_node(s) do v - if isempty(v) - return Set{T}() - else - loaded_v = Set{T}() - len = length(v) - for i in 1:len - load_node(s, i) do _ - push!(loaded_v, load_object(s, T, params[2])) - end - end - return Set{typeof(first(loaded_v))}(loaded_v) - end +function load_object(s::DeserializerState, S::Type{<:Set{T}}, params::Any) where T + elems = load_array_node(s) do _ + load_object(s, T, params) end + return Set(elems) end -function load_object(s::DeserializerState, ::Type{<: Set}, params::Ring) - T = elem_type(params) - loaded_entries = load_array_node(s) do _ - if serialize_with_params(T) - return load_object(s, T, params) - else - return load_object(s, T) - end +function load_object(s::DeserializerState, S::Type{<:Set{T}}, ::Nothing) where T + elems = load_array_node(s) do _ + load_object(s, T, nothing) end - return Set{T}(loaded_entries) + return Set(elems) end ################################################################################ diff --git a/src/Serialization/main.jl b/src/Serialization/main.jl index 3b217e6b98ad..ef93399845b6 100644 --- a/src/Serialization/main.jl +++ b/src/Serialization/main.jl @@ -257,6 +257,34 @@ function save_type_params(s::SerializerState, T::Type{<:Dict{S, U}}, params::Vec end end +function save_type_params(s::SerializerState, T::Type, + params::Vector{<:Pair{Symbol, S}}) where S + save_data_dict(s) do + save_object(s, encode_type(T), :name) + save_data_dict(s, :params) do + for param in params + save_type_params(s, param.second..., Symbol(param.first)) + end + end + end +end + +#function save_type_params(s::SerializerState, T::Type{<:Dict{S, U}}, params::Vector{<:Pair}) where {S, U} +# save_data_dict(s) do +# save_object(s, encode_type(T), :name) +# save_data_dict(s, :params) do +# save_object(s, encode_type(S), :key_type) +# isempty(params) && save_object(s, encode_type(U), :value_type) +# save_data_array(s, :param_pairs) do +# for param in params +# println(param.first) +# println(param.second) +# end +# end +# end +# end +#end + function load_type_params(s::DeserializerState, key::Symbol) load_node(s, key) do _ load_type_params(s) @@ -311,7 +339,7 @@ function load_type_params(s::DeserializerState) load_type_params(s) end end - if T <: MatVecType + if T <: Union{MatVecType, Set} return T{subtype}, params elseif T <: Union{Tuple, NamedTuple} return T{subtype...}, params @@ -766,7 +794,7 @@ function load(io::IO; params::Any = nothing, type::Any = nothing, jsondict_str = JSON3.write(jsondict) s = deserializer_open(IOBuffer(jsondict_str), serializer, - with_attrs) + with_attrs) end try diff --git a/test/Serialization/PolynomialsSeries.jl b/test/Serialization/PolynomialsSeries.jl index 1c9d700a51a2..e4dc0ff22310 100644 --- a/test/Serialization/PolynomialsSeries.jl +++ b/test/Serialization/PolynomialsSeries.jl @@ -45,7 +45,7 @@ cases = [ end end - @test_skip @testset "Graded Ring" begin + @testset "Graded Ring" begin R, (x, y) = QQ[:x, :y] A = [1 3; 2 1] M, (m1, m2) = grade(R, A) @@ -91,7 +91,7 @@ cases = [ end if R isa MPolyRing{T} where T <: Union{QQFieldElem, ZZRingElem, zzModRingElem} - @test_skip @testset "MPoly Ideals over $(case[4])" begin + @testset "MPoly Ideals over $(case[4])" begin q = z i = Oscar.ideal(R, [p, q]) test_save_load_roundtrip(path, i) do loaded_i diff --git a/test/Serialization/containers.jl b/test/Serialization/containers.jl index 90a50a62f88b..b84c5ae2e3c7 100644 --- a/test/Serialization/containers.jl +++ b/test/Serialization/containers.jl @@ -145,7 +145,7 @@ end end - @test_skip @testset "Testing (de)serialization of Set" begin + @testset "Testing (de)serialization of Set" begin original = Set([Set([1, 2])]) test_save_load_roundtrip(path, original) do loaded @test original == loaded @@ -164,7 +164,7 @@ end end - @test_skip @testset "Test for backwards compatibility" begin + @testset "Test for backwards compatibility" begin loaded_container = load(joinpath(@__DIR__, "old-containers.json")) @test loaded_container == (r = QQFieldElem(1, 2), m = QQFieldElem[1//2 1; 0 1], t = (1, 2, 3)) end