Avoid deepcopy

Author: nossleinad

src/MolecularEvolution.jl

@@ -129,6 +129,7 @@ export
 
     #things the user might overload
     copy_partition_to!,
+    copy_partition,
     equilibrium_message,
     sample_partition!,
     obs2partition!,

src/core/nodes/FelNode.jl

@@ -60,10 +60,10 @@ end
 function internal_message_init!(tree::FelNode, empty_message::Vector{<:Partition})
     for node in getnodelist(tree)
         if !isleafnode(node)
-            node.child_messages = [deepcopy(empty_message) for i in node.children]
+            node.child_messages = [copy_message(empty_message) for i in node.children]
         end
-        node.message = deepcopy(empty_message)
-        node.parent_message = deepcopy(empty_message)
+        node.message = copy_message(empty_message)
+        node.parent_message = copy_message(empty_message)
     end
 end
 

src/models/continuous_models/gaussian_partition.jl

@@ -15,6 +15,11 @@ mutable struct GaussianPartition <: ContinuousPartition
     end
 end
 
+#Overloading the copy_partition to avoid deepcopy.
+function copy_partition(src::GaussianPartition)
+    return GaussianPartition(src.mean, src.var, src.norm_const)
+end
+
 #From the first section of http://www.tina-vision.net/docs/memos/2003-003.pdf
 function merge_two_gaussians(g1::GaussianPartition, g2::GaussianPartition)
     #Handling some edge cases. These aren't mathematically sensible. A gaussian with "Inf" variance will behave like a 1,1,1,1 vector in discrete felsenstein.

src/models/discrete_models/discrete_partitions.jl

@@ -10,84 +10,90 @@ function copy_partition_to!(dest::T, src::T) where {T<:DiscretePartition}
     dest.scaling .= src.scaling
 end
 
+#Overloading the copy_partition to avoid deepcopy.
+function copy_partition(src::T) where {T<:DiscretePartition}
+    return T(ntuple(i -> copy(getfield(src, i)), fieldcount(T))...)
+end
+
 #I should add a constructor that constructs a DiscretePartition from an existing array.
 mutable struct CustomDiscretePartition <: DiscretePartition
     state::Array{Float64,2}
     states::Int
     sites::Int
     scaling::Array{Float64,1}
-    function CustomDiscretePartition(states, sites)
-        new(zeros(states, sites), states, sites, zeros(sites))
-    end
-    function CustomDiscretePartition(freq_vec::Vector{Float64}, sites::Int64) #Add this constructor to all partition types
-        state_arr = zeros(length(freq_vec), sites)
-        state_arr .= freq_vec
-        new(state_arr, length(freq_vec), sites, zeros(sites))
-    end
+end
+
+CustomDiscretePartition(states, sites) =
+    CustomDiscretePartition(zeros(states, sites), states, sites, zeros(sites))
+
+function CustomDiscretePartition(freq_vec::Vector{Float64}, sites::Int64) #Add this constructor to all partition types
+    state_arr = zeros(length(freq_vec), sites)
+    state_arr .= freq_vec
+    return CustomDiscretePartition(state_arr, length(freq_vec), sites, zeros(sites))
 end
 
 mutable struct NucleotidePartition <: DiscretePartition
     state::Array{Float64,2}
     states::Int
     sites::Int
     scaling::Array{Float64,1}
-    function NucleotidePartition(sites)
-        new(zeros(4, sites), 4, sites, zeros(sites))
-    end
-    function NucleotidePartition(freq_vec::Vector{Float64}, sites::Int64)
-        @assert length(freq_vec) == 4
-        state_arr = zeros(4, sites)
-        state_arr .= freq_vec
-        new(state_arr, 4, sites, zeros(sites))
-    end
+end
+
+NucleotidePartition(sites) = NucleotidePartition(zeros(4, sites), 4, sites, zeros(sites))
+
+function NucleotidePartition(freq_vec::Vector{Float64}, sites::Int64)
+    @assert length(freq_vec) == 4
+    state_arr = zeros(4, sites)
+    state_arr .= freq_vec
+    return NucleotidePartition(state_arr, 4, sites, zeros(sites))
 end
 
 mutable struct GappyNucleotidePartition <: DiscretePartition
     state::Array{Float64,2}
     states::Int
     sites::Int
     scaling::Array{Float64,1}
-    function GappyNucleotidePartition(sites)
-        new(zeros(5, sites), 5, sites, zeros(sites))
-    end
-    function GappyNucleotidePartition(freq_vec::Vector{Float64}, sites::Int64)
-        @assert length(freq_vec) == 5
-        state_arr = zeros(5, sites)
-        state_arr .= freq_vec
-        new(state_arr, 5, sites, zeros(sites))
-    end
+end
+
+GappyNucleotidePartition(sites) = GappyNucleotidePartition(zeros(5, sites), 5, sites, zeros(sites))
+
+function GappyNucleotidePartition(freq_vec::Vector{Float64}, sites::Int64)
+    @assert length(freq_vec) == 5
+    state_arr = zeros(5, sites)
+    state_arr .= freq_vec
+    return GappyNucleotidePartition(state_arr, 5, sites, zeros(sites))
 end
 
 mutable struct AminoAcidPartition <: DiscretePartition
     state::Array{Float64,2}
     states::Int
     sites::Int
     scaling::Array{Float64,1}
-    function AminoAcidPartition(sites)
-        new(zeros(20, sites), 20, sites, zeros(sites))
-    end
-    function AminoAcidPartition(freq_vec::Vector{Float64}, sites::Int64)
-        @assert length(freq_vec) == 20
-        state_arr = zeros(20, sites)
-        state_arr .= freq_vec
-        new(state_arr, 20, sites, zeros(sites))
-    end
+end
+
+AminoAcidPartition(sites) = AminoAcidPartition(zeros(20, sites), 20, sites, zeros(sites))
+
+function AminoAcidPartition(freq_vec::Vector{Float64}, sites::Int64)
+    @assert length(freq_vec) == 20
+    state_arr = zeros(20, sites)
+    state_arr .= freq_vec
+    return AminoAcidPartition(state_arr, 20, sites, zeros(sites))
 end
 
 mutable struct GappyAminoAcidPartition <: DiscretePartition
     state::Array{Float64,2}
     states::Int
     sites::Int
     scaling::Array{Float64,1}
-    function GappyAminoAcidPartition(sites)
-        new(zeros(21, sites), 21, sites, zeros(sites))
-    end
-    function GappyAminoAcidPartition(freq_vec::Vector{Float64}, sites::Int64)
-        @assert length(freq_vec) == 21
-        state_arr = zeros(21, sites)
-        state_arr .= freq_vec
-        new(state_arr, 21, sites, zeros(sites))
-    end
+end
+
+GappyAminoAcidPartition(sites) = GappyAminoAcidPartition(zeros(21, sites), 21, sites, zeros(sites))
+
+function GappyAminoAcidPartition(freq_vec::Vector{Float64}, sites::Int64)
+    @assert length(freq_vec) == 21
+    state_arr = zeros(21, sites)
+    state_arr .= freq_vec
+    return GappyAminoAcidPartition(state_arr, 21, sites, zeros(sites))
 end
 
 """

src/models/models.jl

@@ -21,6 +21,20 @@ function copy_partition_to!(dest::GaussianPartition,src::GaussianPartition)
 end
 =#
 
+#Fallback method. This should be overloaded to avoid deepcopy wherever performance requires it
+function copy_partition(src::T) where {T <: Partition}
+    return deepcopy(src)
+end
+
+#Example overloading for GaussianPartition:
+#=
+function copy_partition(src::GaussianPartition)
+    return GaussianPartition(src.mean, src.var, src.norm_const)
+end
+=#
+
+copy_message(msg::Vector{<:Partition}) = [copy_partition(x) for x in msg]
+
 #This is a function shared for all models - perhaps move this elsewhere
 function combine!(dest::T, source_arr::Vector{<:T}, wipe::Bool) where {T<:Partition}
     #Init to be equal to 1, then multiply everything on.