first attempts at writing the serializers for the new types PhylogeneticModel and GroupBasedPhylogeneticModel

experimental/AlgebraicStatistics/src/AlgebraicStatistics.jl

@@ -6,6 +6,8 @@ include("PhylogeneticModels.jl")
 include("PhylogeneticAuxiliary.jl")
 include("PhylogeneticParametrization.jl")
 
+include("serialization.jl")
+
 #export models
 export cavender_farris_neyman_model
 export jukes_cantor_model

experimental/AlgebraicStatistics/src/PhylogeneticModels.jl

@@ -6,7 +6,7 @@ struct PhylogeneticModel
   graph::Graph{Directed}
   n_states::Int
   prob_ring::MPolyRing{QQFieldElem}
-  root_distr::Vector{Any}
+  root_distr::Vector
   trans_matrices::Dict{Edge, MatElem{QQMPolyRingElem}}
 end
 

experimental/AlgebraicStatistics/src/serialization.jl

@@ -0,0 +1,42 @@
+@register_serialization_type PhylogeneticModel 
+@register_serialization_type GroupBasedPhylogeneticModel 
+
+function save_object(s::SerializerState, pm::PhylogeneticModel)
+  save_data_dict(s) do 
+    save_typed_object(s, graph(pm), :tree) # already implemented 
+    save_object(s, number_states(pm), :states) # already implemented 
+    save_typed_object(s, probability_ring(pm), :probability_ring) # already implemented
+    save_object(s, root_distribution(pm), :root_distribution) # needs to be implemented, or we change the entry type to QQFieldElem
+    save_typed_object(s, transition_matrices(pm), :transition_matrices) # needs to be implemented
+  end
+end
+
+function save_object(s::SerializerState, pm::GroupBasedPhylogeneticModel)
+  save_data_dict(s) do
+    save_object(s, phylogenetic_model(pm), :phylomodel) # details see above
+    save_typed_object(s, fourier_ring(pm), :fourier_ring) # already implemented
+    save_typed_object(s, fourier_parameters(pm), :fourier_params) # needs to be implemented
+    save_typed_object(s, group_of_model(pm), :group) # already implemented
+  end
+end
+
+
+function load_object(s::DeserializerState, g::Type{PhylogeneticModel})
+  graph = load_object(s, Graph{Directed}, :tree)
+  n_states = load_object(s, Int64, :states)
+  prob_ring = load_typed_object(s, :probability_ring)
+  root_distr = load_object(s, Vector, QQ, :root_distribution)
+  params = load_type_params(s, Dict{Edge, MatElem{QQMPolyRingElem}})
+  trans_matrices = load_typed_object(s, :transition_matrices, params)
+
+  return PhylogeneticModel(graph, n_states, prob_ring, root_distr, trans_matrices)
+end 
+
+function load_object(s::DeserializerState, g::Type{GroupBasedPhylogeneticModel})
+  phylomodel = load_object(s, PhylogeneticModel, :phylomodel)
+  fourier_ring = load_typed_object(s, :fourier_ring)
+  fourier_params = load_typed_object(s, :fourier_params)
+  group = load_typed_object(s, :group)
+
+  return GroupBasedPhylogeneticModel(phylomodel, fourier_ring, fourier_params, group)
+end

src/Serialization/Combinatorics.jl

@@ -5,6 +5,7 @@ using JSON
 ###############################################################################
 @register_serialization_type Graph{Directed} "Graph{Directed}"
 @register_serialization_type Graph{Undirected} "Graph{Undirected}"
+@register_serialization_type Edge
 
 function save_object(s::SerializerState, g::Graph{T}) where T <: Union{Directed, Undirected}
   smallobject = pm_object(g)
@@ -19,6 +20,17 @@ function load_object(s::DeserializerState, g::Type{Graph{T}}) where T <: Union{D
   return g(smallobj)
 end
 
+function save_object(s::SerializerState, e::Edge)
+  save_data_array(s) do 
+    save_object(s, src(e))
+    save_object(s, dst(e))
+  end
+end
+
+function load_object(s::DeserializerState, e::Type{Edge})
+  return Edge(load_object(s, Int, 1), load_object(s, Int, 2))
+end
+
 ###############################################################################
 ## Matroid
 ###############################################################################

src/Serialization/containers.jl

@@ -413,24 +413,28 @@ function load_object(s::DeserializerState, ::Type{<:Dict}, params::Dict{Symbol,
 
     if key_type == Int
       key = parse(Int, string(k))
-    elseif haskey(params, :key_params) # type is not Int, String or Symbol
+    elseif key_type <: Union{Symbol, String}
+      key = key_type(k)
+    elseif serialize_with_params(key_type)
       load_node(s, i) do _
         # 1 is for first entry of tuple which is the key in this case
         key = load_object(s, key_type, params[:key_params], 1) 
       end
-    else
-      key = key_type(k)
+    else 
+      load_node(s,i) do _ 
+        key = load_object(s, key_type, 1)
+      end
     end
 
     if value_type != Any
       if serialize_with_params(value_type)
-        if haskey(params, :key_params) # key type is not Int, String or Symbol
+        if key_type <: Union{Symbol, String}
+          dict[key] = load_object(s, value_type, params[:value_params], k)
+        else
           load_node(s, i) do _
             # 2 is for second entry of tuple which is the value in this case
             dict[key] = load_object(s, value_type, params[:value_params], 2) 
           end
-        else
-          dict[key] = load_object(s, value_type, params[:value_params], k)
         end
       else
         if haskey(params, :key_params) # key type is not Int, String or Symbol